diff --git a/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-/react-common_v3.x.x.js b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-v0.200.x/react-common_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-/react-common_v3.x.x.js
rename to definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-v0.200.x/react-common_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-/test_react-common_v3.x.x.js b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-v0.200.x/test_react-common_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-/test_react-common_v3.x.x.js
rename to definitions/npm/@apollo/react-common_v3.x.x/flow_v0.104.x-v0.200.x/test_react-common_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/react-common_v3.x.x.js b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/react-common_v3.x.x.js
new file mode 100644
index 0000000000..d23fb244d5
--- /dev/null
+++ b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/react-common_v3.x.x.js
@@ -0,0 +1,1050 @@
+declare module '@apollo/react-common' {
+  import type { Node } from 'react';
+
+  /* start utils */
+  declare export type Record<T, U> = {
+    [key: $Keys<T>]: U,
+    ...,
+  };
+  /* end utils */
+
+  /* start graphql */
+  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 graphql */
+
+  /* start context */
+  declare export type ApolloContextValue = {
+    client?: ApolloClient<any>,
+    renderPromises?: Record<any, any>,
+    ...
+  };
+
+  declare export type ApolloProviderProps<TCache> = {
+    client: ApolloClient<TCache>,
+    children: Node | Node[] | null,
+    ...
+  };
+
+  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 function getApolloContext<T>(): T;
+
+  declare export interface ApolloConsumerProps {
+    children: (client: ApolloClient<any>) => Node;
+  }
+
+  declare export class ApolloConsumer extends React$Component<ApolloConsumerProps> {}
+  declare export function resetApolloContext(): void;
+
+  /* end context */
+
+  /* start parser */
+  declare export type DocumentType = 'Query' | 'Mutation' | 'Subscription';
+
+  declare export type IDocumentDefinition = {
+    type: DocumentType,
+    name: string,
+    variables: $ReadOnlyArray <VariableDefinitionNode>,
+    ...
+  };
+
+  declare export function operationName(type: DocumentType): string;
+
+  declare export function parser(document: DocumentNode): IDocumentDefinition;
+  /* end parser */
+
+  /* start operation types */
+  declare export type OperationVariables = Record<string, any>;
+
+  declare export type Context = Record<string, any>;
+
+  /* Query types */
+  declare export type BaseQueryOptions<TVariables> = {
+    ssr?: boolean,
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    pollInterval?: number,
+    client?: ApolloClient<any>,
+    notifyOnNetworkStatusChange?: boolean,
+    context?: Context,
+    partialRefetch?: boolean,
+    returnPartialData?: boolean,
+    ...
+  };
+
+  declare export type QueryFunctionOptions<
+    TData,
+    TVariables
+  > = BaseQueryOptions<TVariables> & {
+    displayName?: string,
+    skip?: boolean,
+    onCompleted?: (data: TData) => void,
+    onError?: (error: ApolloError) => void,
+    ...
+  };
+
+  declare export type ObservableQueryFields<TData, TVariables> = {
+    startPolling: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'startPolling'
+    >,
+    stopPolling: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'stopPolling'
+    >,
+    subscribeToMore: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'subscribeToMore'
+    >,
+    updateQuery: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'updateQuery'
+    >,
+    refetch: $PropertyType<ObservableQuery<TData, TVariables>, 'refetch'>,
+    variables: $PropertyType<ObservableQuery<TData, TVariables>, 'variables'>,
+    fetchMore: (<TVariables>(
+      fetchMoreOptions: FetchMoreQueryOptions<TVariables> &
+        FetchMoreOptions<TData, TVariables>
+    ) => Promise<ApolloQueryResult<TData>>) &
+      (<TData2, TVariables2>(
+        fetchMoreOptions: {
+          query?: DocumentNode,
+          ...
+        } & FetchMoreQueryOptions<TVariables2> &
+          FetchMoreOptions<TData2, TVariables2>
+      ) => Promise<ApolloQueryResult<TData2>>),
+    ...
+  };
+
+  declare export type QueryResult<TData, TVariables> = ObservableQueryFields<
+    TData,
+    TVariables
+  > & {
+    client: ApolloClient<any>,
+    data: ?TData,
+    error?: ApolloError,
+    loading: boolean,
+    networkStatus: NetworkStatusRaw,
+    called: boolean,
+    ...
+  };
+
+  /* Mutation types */
+  declare export type RefetchQueriesFunction = (
+    ...args: any[]
+  ) => Array<string | PureQueryOptions>;
+
+  declare export type BaseMutationOptions<TData, TVariables> = {
+    variables?: TVariables,
+    optimisticResponse?: TData | ((vars: TVariables) => TData),
+    refetchQueries?: Array<string | PureQueryOptions> | RefetchQueriesFunction,
+    awaitRefetchQueries?: boolean,
+    errorPolicy?: ErrorPolicy,
+    update?: MutationUpdaterFn<TData>,
+    client?: ApolloClient<any>,
+    notifyOnNetworkStatusChange?: boolean,
+    context?: Context,
+    onCompleted?: (data: TData) => void,
+    onError?: (error: ApolloError) => void,
+    fetchPolicy?: FetchPolicy,
+    ignoreResults?: boolean,
+    ...
+  };
+
+  declare export type MutationFunctionOptions<TData, TVariables> = {
+    variables?: TVariables,
+    optimisticResponse?: TData | ((vars: TVariables | { ... }) => TData),
+    refetchQueries?: Array<string | PureQueryOptions> | RefetchQueriesFunction,
+    awaitRefetchQueries?: boolean,
+    update?: MutationUpdaterFn<TData>,
+    context?: Context,
+    fetchPolicy?: FetchPolicy,
+    ...
+  };
+
+  declare export type MutationResult<TData> = {
+    data?: TData,
+    error?: ApolloError,
+    loading: boolean,
+    called: boolean,
+    client?: ApolloClient<any>,
+    ...
+  };
+
+  declare export type MutationFetchResult<
+    TData = Record<string, any>,
+    C = Record<string, any>,
+    E = Record<string, any>
+  > = ExecutionResult<TData> & {
+    extensions?: E,
+    context?: C,
+    ...
+  };
+
+  declare export type MutationFunction<TData, TVariables> = (
+    options?: MutationFunctionOptions<TData, TVariables>
+  ) => Promise<MutationFetchResult<TData>>;
+
+  /* Subscription types */
+  declare export type OnSubscriptionDataOptions<TData> = {
+    client: ApolloClient<any>,
+    subscriptionData: SubscriptionResult<TData>,
+    ...
+  };
+
+  declare export type BaseSubscriptionOptions<TData, TVariables> = {
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    shouldResubscribe?:
+      | boolean
+      | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean),
+    client?: ApolloClient<any>,
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any,
+    onSubscriptionComplete?: () => void,
+    ...
+  };
+
+  declare export type SubscriptionResult<TData> = {
+    loading: boolean,
+    data?: TData,
+    error?: ApolloError,
+    ...
+  };
+  /* end operation types */
+
+  /* start apollo-client 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) => any
+    ): 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?: () => void,
+      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) => void) | void,
+      optimisticResponse: any,
+      ...
+    }): void;
+    markMutationResult(mutation: {
+      mutationId: string,
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: {
+        [queryId: string]: QueryWithUpdater,
+        ...,
+      },
+      update: ((proxy: DataProxy, mutationResult: any) => void) | void,
+      ...
+    }): void;
+    markMutationComplete({
+      mutationId: string,
+      optimisticResponse?: any,
+      ...
+    }): 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: NetworkStatusRaw,
+    error?: ApolloError,
+    partial?: boolean,
+    ...
+  };
+
+  declare export type ModifiableWatchQueryOptions = {
+    variables?: {
+      [key: string]: any,
+      ...,
+    },
+    pollInterval?: number,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    fetchResults?: boolean,
+    notifyOnNetworkStatusChange?: boolean,
+    ...
+  };
+
+  declare export type WatchQueryOptions = {
+    ...$Exact<ModifiableWatchQueryOptions>,
+    query: DocumentNode,
+    metadata?: any,
+    context?: any,
+    ...
+  };
+
+  declare export type RefetchQueryDescription = Array<
+    string | PureQueryOptions
+  >;
+
+  declare export interface MutationBaseOptions<
+    T = {
+      [key: string]: any,
+      ...,
+    }
+  > {
+    optimisticResponse?: any;
+    updateQueries?: MutationQueryReducersMap<T>;
+    optimisticResponse?: any;
+    refetchQueries?:
+      | ((result: ExecutionResult<>) => RefetchQueryDescription)
+      | RefetchQueryDescription;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: 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) => void,
+    ...
+  };
+
+  declare export type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => void;
+
+  declare export type NetworkStatusRaw = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare export class NetworkStatus {
+    [NetworkStatusRaw]: string;
+    string: NetworkStatusRaw;
+  }
+
+  declare export type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => void;
+
+  declare export type QueryStoreValue = {
+    document: DocumentNode,
+    variables: any,
+    previousVariables: any,
+    networkStatus: NetworkStatusRaw,
+    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: NetworkStatusRaw,
+    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 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 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<T, D>(options: SubscriptionOptions<T, D>): Observable<any>;
+    readQuery<T, D>(options: DataProxyReadQueryOptions): T | null;
+    readFragment<TData, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>
+    ): TData | null;
+    writeQuery<TData, TVariables>(
+      options: DataProxyWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: DataProxyWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: DataProxyWriteDataOptions<TData>): void;
+    __actionHookForDevTools(cb: () => any): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    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?: {
+      [key: string]: any,
+      ...,
+    };
+    operationName?: string;
+    context?: {
+      [key: string]: any,
+      ...,
+    };
+    extensions?: {
+      [key: string]: any,
+      ...,
+    };
+  }
+
+  declare export 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 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) => void) | ZenObservableObserver<T>,
+      error?: (error: any) => void,
+      complete?: () => void
+    ): ZenObservableSubscription;
+    forEach(fn: (value: T) => void): 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) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare export type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => void | (() => void) | 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, TVariables>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery<TData, TVariables>(
+      options: CacheWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: CacheWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: CacheWriteDataOptions<TData>): void;
+  }
+
+  declare export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+  declare export type CacheWatchCallback = (newData: any) => void;
+
+  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<
+    TData,
+    TVariables
+  > = DataProxyWriteQueryOptions<TData, TVariables>;
+  declare export type CacheWriteFragmentOptions<
+    TData,
+    TVariables
+  > = DataProxyWriteFragmentOptions<TData, TVariables>;
+  declare export type CacheWriteDataOptions<
+    TData
+  > = DataProxyWriteDataOptions<TData>;
+
+  declare export interface DataProxyReadQueryOptions {
+    query: DocumentNode;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyReadFragmentOptions<TVariables> {
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteQueryOptions<TData, TVariables> {
+    data: TData;
+    query: DocumentNode;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteFragmentOptions<TData, TVariables> {
+    data: TData;
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteDataOptions<TData> {
+    data: TData;
+    id?: string;
+  }
+
+  declare export type DataProxyDiffResult<T> = {
+    result?: T,
+    complete?: boolean,
+    ...
+  };
+
+  declare export interface DataProxy {
+    readQuery<QueryType, TVariables>(
+      options: DataProxyReadQueryOptions,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery<TData, TVariables>(
+      options: DataProxyWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: DataProxyWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: DataProxyWriteDataOptions<TData>): void;
+  }
+  /* End apollo-cache types */
+  /* end apollo-client types */
+}
diff --git a/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/test_react-common_v3.x.x.js b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/test_react-common_v3.x.x.js
new file mode 100644
index 0000000000..afe610790e
--- /dev/null
+++ b/definitions/npm/@apollo/react-common_v3.x.x/flow_v0.201.x-/test_react-common_v3.x.x.js
@@ -0,0 +1,119 @@
+// @flow
+
+import * as React from 'react';
+import { it, describe } from 'flow-typed-test';
+import {
+  ApolloProvider,
+  ApolloConsumer,
+  parser,
+  operationName,
+  type DocumentType,
+  type IDocumentDefinition
+} from '@apollo/react-common';
+
+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[],
+  ...
+};
+
+const HERO_QUERY = gql`
+  query GetCharacter($episode: String!, $offset: Int) {
+    hero(episode: $episode, offset: $offset) {
+      name
+      id
+      friends {
+        name
+        id
+        appearsIn
+      }
+    }
+  }
+`;
+
+describe('<ApolloProvider />', () => {
+  it('works when passed client', () => {
+    // $FlowExpectedError Should be an instance of ApolloClient
+    const client = {};
+    <ApolloProvider client={client}>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed a client', () => {
+    // $FlowExpectedError ApolloProvider requires client prop
+    <ApolloProvider>
+      <div />
+    </ApolloProvider>;
+  });
+
+  it('raises an error when not passed children', () => {
+    // Should be an instance of ApolloClient
+    const client = {};
+
+    // $FlowExpectedError ApolloProvider 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>;
+  });
+});
+
+describe('parser', () => {
+  it('returns IDocumentDefinition', () => {
+    const document = {};
+
+    const result = parser({});
+
+    (result: IDocumentDefinition);
+    // $FlowExpectedError
+    (result: number);
+  })
+})
+
+describe('operationName', () => {
+  it('works', () => {
+    const result = operationName('Query');
+
+    (result: string);
+    // $FlowExpectedError
+    (result: number);
+  })
+
+  it('requires DocumentType', () => {
+    // $FlowExpectedError must be a DocumentType
+    const result = operationName('foo');
+  })
+})
diff --git a/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-/react-hooks_v3.x.x.js b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-v0.200.x/react-hooks_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-/react-hooks_v3.x.x.js
rename to definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-v0.200.x/react-hooks_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-/test_react-hooks_v3.x.x.js b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-v0.200.x/test_react-hooks_v3.x.x.js
similarity index 100%
rename from definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-/test_react-hooks_v3.x.x.js
rename to definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.104.x-v0.200.x/test_react-hooks_v3.x.x.js
diff --git a/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/react-hooks_v3.x.x.js b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/react-hooks_v3.x.x.js
new file mode 100644
index 0000000000..66ae3284e1
--- /dev/null
+++ b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/react-hooks_v3.x.x.js
@@ -0,0 +1,1046 @@
+declare module '@apollo/react-hooks' {
+  import type { ComponentType, Element, Node } from 'react';
+
+  /* start graphql types */
+  declare export type DocumentNode = any;
+  declare export type GraphQLError = any;
+  /* end graphql types */
+
+  /* start @apollo/react-common types */
+  declare export type ApolloProviderProps<TCache> = {|
+    client: ApolloClient<TCache>,
+    children: Node | Node[] | null,
+  |};
+
+  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 interface ApolloConsumerProps {
+    children: (client: ApolloClient<any>) => Node;
+  }
+
+  declare export class ApolloConsumer extends React$Component<ApolloConsumerProps> {}
+
+  declare export function getApolloContext<T>(): T;
+  declare export function resetApolloContext(): void;
+  /* end @apollo/react-common types */
+
+  /* start @apollo/react-hooks types */
+  declare export type Record<T, U> = {| [key: $Keys<T>]: U |};
+
+  declare export function useQuery<TData, TVariables>(
+    query: DocumentNode,
+    options?: QueryHookOptions<TData, TVariables>
+  ): QueryResult<TData, TVariables>;
+
+  declare export function useLazyQuery<TData, TVariables>(
+    query: DocumentNode,
+    options?: LazyQueryHookOptions<TData, TVariables>
+  ): [
+    (options?: QueryLazyOptions<TVariables>) => void,
+    QueryResult<TData, TVariables>
+  ];
+
+  declare export function useSubscription<TData, TVariables>(
+    query: DocumentNode,
+    options?: SubscriptionHookOptions<TData, TVariables>
+  ): QueryResult<TData, TVariables>;
+
+  declare export function useMutation<TData, TVariables>(
+    query: DocumentNode,
+    options?: MutationHookOptions<TData, TVariables>
+  ): MutationTuple<TData, TVariables>;
+
+  declare export function useApolloClient<T>(): ApolloClient<T>;
+
+  declare export class RenderPromises {
+    registerSSRObservable<TData, TVariables>(
+      observable: ObservableQuery<any, TVariables>,
+      props: QueryOptions<TData, TVariables>
+    ): void;
+    addQueryPromise<TData, TVariables>(
+      queryInstance: QueryData<TData, TVariables>,
+      finish: () => Node
+    ): Node;
+    hasPromises(): boolean;
+    consumeAndAwaitPromises(): Promise<void>;
+  }
+
+  declare export class QueryData<TData, TVariables> {
+    execute(): QueryResult<TData, TVariables>;
+    executeLazy(): QueryTuple<TData, TVariables>;
+    fetchData(): Promise<ApolloQueryResult<any>> | boolean;
+    afterExecute({| lazy?: boolean |}): any;
+    cleanup(): void;
+    getOptions(): any;
+  }
+
+  /* Common types */
+  declare export type CommonOptions<TOptions> = {|
+    ...TOptions,
+    client?: ApolloClient<any>,
+  |};
+
+  /* Query types */
+  declare export type QueryOptions<TData, TVariables> = {|
+    ...QueryFunctionOptions<TData, TVariables>,
+    children?: (result: QueryResult<TData, TVariables>) => Node,
+    query: DocumentNode,
+  |};
+
+  declare export type QueryHookOptions<TData, TVariables> = {|
+    ...QueryFunctionOptions<TData, TVariables>,
+    query?: DocumentNode,
+  |};
+
+  declare export type LazyQueryHookOptions<TData, TVariables> = {|
+    ...$Diff<QueryFunctionOptions<TData, TVariables>, {| skip: any |}>,
+    query?: DocumentNode,
+  |};
+
+  declare export type QueryPreviousData<TData, TVariables> = {|
+    client?: ApolloClient<any>,
+    query?: DocumentNode,
+    observableQueryOptions?: any,
+    result?: ApolloQueryResult<TData> | null,
+    loading?: boolean,
+    options?: QueryOptions<TData, TVariables>,
+  |};
+
+  declare export type QueryCurrentObservable<TData, TVariables> = {|
+    query?: ObservableQuery<TData, TVariables> | null,
+    subscription?: ZenObservableSubscription,
+  |};
+
+  declare export type QueryLazyOptions<TVariables> = {|
+    variables?: TVariables,
+    context?: Context,
+  |};
+
+  declare export type QueryTuple<TData, TVariables> = [
+    (options?: QueryLazyOptions<TVariables>) => void,
+    QueryResult<TData, TVariables>
+  ];
+
+  /* Mutation types */
+  declare export type MutationHookOptions<TData, TVariables> = {|
+    ...BaseMutationOptions<TData, TVariables>,
+    mutation?: DocumentNode,
+  |};
+
+  declare export type MutationOptions<TData, TVariables> = {|
+    ...BaseMutationOptions<TData, TVariables>,
+    mutation: DocumentNode,
+  |};
+
+  declare export type MutationTuple<TData, TVariables> = [
+    (
+      options?: MutationFunctionOptions<TData, TVariables>
+    ) => Promise<ExecutionResult<TData>>,
+    MutationResult<TData>
+  ];
+
+  /* Subscription types */
+  declare export type SubscriptionHookOptions<TData, TVariables> = {|
+    ...BaseSubscriptionOptions<TData, TVariables>,
+    subscription?: DocumentNode,
+  |};
+
+  declare export type SubscriptionOptions<TData, TVariables> = {|
+    ...BaseSubscriptionOptions<TData, TVariables>,
+    subscription: DocumentNode,
+    children?:
+      | null
+      | ((result: SubscriptionResult<TData>) => Element<any> | null),
+  |};
+
+  declare export type SubscriptionCurrentObservable = {|
+    query?: Observable<any>,
+    subscription?: ZenObservableSubscription,
+  |};
+
+  /* Common types */
+  declare export type OperationVariables = Record<string, any>;
+
+  declare export type Context = Record<string, any>;
+
+  declare export type ExecutionResult<T> = {|
+    data?: T,
+    extensions?: Record<string, any>,
+    errors?: GraphQLError[],
+  |};
+
+  /* Query types */
+  declare export type BaseQueryOptions<TVariables> = {|
+    ssr?: boolean,
+    variables?: TVariables,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    pollInterval?: number,
+    client?: ApolloClient<any>,
+    notifyOnNetworkStatusChange?: boolean,
+    context?: Context,
+    partialRefetch?: boolean,
+    returnPartialData?: boolean,
+  |};
+
+  declare export type QueryFunctionOptions<TData, TVariables> = {|
+    ...BaseQueryOptions<TVariables>,
+    displayName?: string,
+    skip?: boolean,
+    onCompleted?: (data: TData) => void,
+    onError?: (error: ApolloError) => void,
+  |};
+
+  declare export type ObservableQueryFields<TData, TVariables> = {|
+    startPolling: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'startPolling'
+    >,
+    stopPolling: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'stopPolling'
+    >,
+    subscribeToMore: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'subscribeToMore'
+    >,
+    updateQuery: $PropertyType<
+      ObservableQuery<TData, TVariables>,
+      'updateQuery'
+    >,
+    refetch: $PropertyType<ObservableQuery<TData, TVariables>, 'refetch'>,
+    variables: $PropertyType<ObservableQuery<TData, TVariables>, 'variables'>,
+    fetchMore: (<TVariables>(fetchMoreOptions: {|
+      ...$Exact<FetchMoreQueryOptions<TVariables>>,
+      ...$Exact<FetchMoreOptions<TData, TVariables>>,
+    |}) => Promise<ApolloQueryResult<TData>>) &
+      (<TData2, TVariables2>(fetchMoreOptions: {|
+        query?: DocumentNode,
+        ...$Exact<FetchMoreQueryOptions<TVariables2>>,
+        ...$Exact<FetchMoreOptions<TData2, TVariables2>>,
+      |}) => Promise<ApolloQueryResult<TData2>>),
+  |};
+
+  declare export type QueryResult<TData, TVariables> = {|
+    ...ObservableQueryFields<TData, TVariables>,
+    client: ApolloClient<any>,
+    data: ?TData,
+    error?: ApolloError,
+    loading: boolean,
+    networkStatus: NetworkStatus,
+    called: boolean,
+  |};
+
+  /* Mutation types */
+  declare export type RefetchQueriesFunction = (
+    ...args: any[]
+  ) => Array<string | PureQueryOptions>;
+
+  declare export type BaseMutationOptions<TData, TVariables> = {|
+    variables?: TVariables,
+    optimisticResponse?: TData | ((vars: TVariables) => TData),
+    refetchQueries?: Array<string | PureQueryOptions> | RefetchQueriesFunction,
+    awaitRefetchQueries?: boolean,
+    errorPolicy?: ErrorPolicy,
+    update?: MutationUpdaterFn<TData>,
+    client?: ApolloClient<any>,
+    notifyOnNetworkStatusChange?: boolean,
+    context?: Context,
+    onCompleted?: (data: TData) => void,
+    onError?: (error: ApolloError) => void,
+    fetchPolicy?: FetchPolicy,
+    ignoreResults?: boolean,
+  |};
+
+  declare export type MutationFunctionOptions<TData, TVariables> = {|
+    variables?: TVariables,
+    optimisticResponse?: TData | ((vars: TVariables | {||}) => TData),
+    refetchQueries?: Array<string | PureQueryOptions> | RefetchQueriesFunction,
+    awaitRefetchQueries?: boolean,
+    update?: MutationUpdaterFn<TData>,
+    context?: Context,
+    fetchPolicy?: FetchPolicy,
+  |};
+
+  declare export type MutationResult<TData> = {|
+    data?: TData,
+    error?: ApolloError,
+    loading: boolean,
+    called: boolean,
+    client?: ApolloClient<any>,
+  |};
+
+  declare export type MutationFetchResult<
+    TData = Record<string, any>,
+    C = Record<string, any>,
+    E = Record<string, any>
+  > = {|
+    ...ExecutionResult<TData>,
+    extensions?: E,
+    context?: C,
+  |};
+
+  declare export type MutationFunction<TData, TVariables> = (
+    options?: MutationFunctionOptions<TData, TVariables>
+  ) => Promise<MutationFetchResult<TData>>;
+
+  /* Subscription types */
+  declare export type OnSubscriptionDataOptions<TData> = {|
+    client: ApolloClient<any>,
+    subscriptionData: SubscriptionResult<TData>,
+  |};
+
+  declare export type BaseSubscriptionOptions<TData, TVariables> = {|
+    variables?: TVariables,
+    skip?: boolean,
+    fetchPolicy?: FetchPolicy,
+    shouldResubscribe?:
+      | boolean
+      | ((options: BaseSubscriptionOptions<TData, TVariables>) => boolean),
+    client?: ApolloClient<any>,
+    onSubscriptionData?: (options: OnSubscriptionDataOptions<TData>) => any,
+    onSubscriptionComplete?: () => void,
+  |};
+
+  declare export type SubscriptionResult<TData> = {|
+    loading: boolean,
+    data?: TData,
+    error?: ApolloError,
+  |};
+
+  /* end @apollo/react-hooks types */
+
+  /* start apollo-client 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: {|
+      ...$Exact<FetchMoreQueryOptions<any>>,
+      ...$Exact<FetchMoreOptions<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) => any
+    ): 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?: () => void,
+      ssrMode?: boolean,
+    |}): this;
+    mutate<T>(options: MutationOptions<T, any>): 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) => void) | void,
+      optimisticResponse: any,
+    |}): void;
+    markMutationResult(mutation: {|
+      mutationId: string,
+      result: ExecutionResult<>,
+      document: DocumentNode,
+      variables: any,
+      updateQueries: {| [queryId: string]: QueryWithUpdater |},
+      update: ((proxy: DataProxy, mutationResult: any) => void) | void,
+    |}): void;
+    markMutationComplete({|
+      mutationId: string,
+      optimisticResponse?: any,
+    |}): 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 type 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 type ModifiableWatchQueryOptions = {|
+    variables?: {| [key: string]: any |},
+    pollInterval?: number,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    fetchResults?: boolean,
+    notifyOnNetworkStatusChange?: boolean,
+  |};
+
+  declare export type WatchQueryOptions = {|
+    ...$Exact<ModifiableWatchQueryOptions>,
+    query: DocumentNode,
+    metadata?: any,
+    context?: any,
+  |};
+
+  declare export type RefetchQueryDescription = Array<
+    string | PureQueryOptions
+  >;
+
+  declare export interface MutationBaseOptions<
+    T = {
+      [key: string]: any,
+      ...,
+    }
+  > {
+    optimisticResponse?: any;
+    updateQueries?: MutationQueryReducersMap<T>;
+    optimisticResponse?: any;
+    refetchQueries?:
+      | ((result: ExecutionResult<>) => RefetchQueryDescription)
+      | RefetchQueryDescription;
+    update?: MutationUpdaterFn<T>;
+    errorPolicy?: ErrorPolicy;
+    variables?: 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 type 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) => void,
+  |};
+
+  declare export type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => void;
+
+  declare export type NetworkStatus = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare export type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => void;
+
+  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?: {| [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 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 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, any>): Promise<FetchResult<T>>;
+    subscribe<T, D>(options: SubscriptionOptions<T, D>): Observable<any>;
+    readQuery<T, D>(options: DataProxyReadQueryOptions<D>): T | null;
+    readFragment<TData, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>
+    ): TData | null;
+    writeQuery<TData, TVariables>(
+      options: DataProxyWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: DataProxyWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: DataProxyWriteDataOptions<TData>): void;
+    __actionHookForDevTools(cb: () => any): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    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?: {| [key: string]: any |};
+    operationName?: string;
+    context?: {| [key: string]: any |};
+    extensions?: {| [key: string]: any |};
+  }
+
+  declare export 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 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) => void) | ZenObservableObserver<T>,
+      error?: (error: any) => void,
+      complete?: () => void
+    ): ZenObservableSubscription;
+    forEach(fn: (value: T) => void): 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) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare export type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => void | (() => void) | 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, TVariables>(
+      options: DataProxyReadQueryOptions<TVariables>,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery<TData, TVariables>(
+      options: CacheWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: CacheWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: CacheWriteDataOptions<TData>): void;
+  }
+
+  declare export type Transaction<T> = (c: ApolloCache<T>) => void;
+
+  declare export type CacheWatchCallback = (newData: any) => void;
+
+  declare export interface CacheEvictionResult {
+    success: boolean;
+  }
+
+  declare export interface CacheReadOptions
+    extends DataProxyReadQueryOptions<any> {
+    rootId?: string;
+    previousResult?: any;
+    optimistic: boolean;
+  }
+
+  declare export interface CacheWriteOptions
+    extends DataProxyReadQueryOptions<any> {
+    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<any> {
+    rootId?: string;
+  }
+
+  declare export type CacheDiffResult<T> = DataProxyDiffResult<T>;
+  declare export type CacheWriteQueryOptions<
+    TData,
+    TVariables
+  > = DataProxyWriteQueryOptions<TData, TVariables>;
+  declare export type CacheWriteFragmentOptions<
+    TData,
+    TVariables
+  > = DataProxyWriteFragmentOptions<TData, TVariables>;
+  declare export type CacheWriteDataOptions<
+    TData
+  > = DataProxyWriteDataOptions<TData>;
+
+  declare export interface DataProxyReadQueryOptions<D> {
+    query: DocumentNode;
+    variables?: D;
+  }
+
+  declare export interface DataProxyReadFragmentOptions<TVariables> {
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteQueryOptions<TData, TVariables> {
+    data: TData;
+    query: DocumentNode;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteFragmentOptions<TData, TVariables> {
+    data: TData;
+    id: string;
+    fragment: DocumentNode;
+    fragmentName?: string;
+    variables?: TVariables;
+  }
+
+  declare export interface DataProxyWriteDataOptions<TData> {
+    data: TData;
+    id?: string;
+  }
+
+  declare export type DataProxyDiffResult<T> = {|
+    result?: T,
+    complete?: boolean,
+  |};
+
+  declare export interface DataProxy {
+    readQuery<QueryType, TVariables>(
+      options: DataProxyReadQueryOptions<TVariables>,
+      optimistic?: boolean
+    ): QueryType | null;
+    readFragment<FragmentType, TVariables>(
+      options: DataProxyReadFragmentOptions<TVariables>,
+      optimistic?: boolean
+    ): FragmentType | null;
+    writeQuery<TData, TVariables>(
+      options: DataProxyWriteQueryOptions<TData, TVariables>
+    ): void;
+    writeFragment<TData, TVariables>(
+      options: DataProxyWriteFragmentOptions<TData, TVariables>
+    ): void;
+    writeData<TData>(options: DataProxyWriteDataOptions<TData>): void;
+  }
+  /* End apollo-cache types */
+  /* end apollo-client types */
+}
diff --git a/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/test_react-hooks_v3.x.x.js b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/test_react-hooks_v3.x.x.js
new file mode 100644
index 0000000000..cde25e5fbb
--- /dev/null
+++ b/definitions/npm/@apollo/react-hooks_v3.x.x/flow_v0.201.x-/test_react-hooks_v3.x.x.js
@@ -0,0 +1,143 @@
+// @flow
+import * as React from 'react';
+import { it, describe } from 'flow-typed-test';
+import {
+  useQuery,
+  useMutation,
+  useSubscription,
+  useLazyQuery,
+  useApolloClient,
+} from '@apollo/react-hooks';
+
+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,
+  ...
+};
+
+describe('useQuery hook', () => {
+  type Data = {
+    a: string,
+    b: string,
+    ...
+  };
+  type Variables = {
+    c: string,
+    ...
+  };
+  const result = useQuery<Data, Variables>('test');
+
+  const { data, loading, error } = result;
+  it('handles data correctly', () => {
+    if (data) {
+      const a: string = data.a;
+      // $FlowExpectedError
+      const b: number = data.b;
+    }
+  });
+  it('handles loading state correctly', () => {
+    if (error) {
+      (error.message: string);
+      (error.graphQLErrors: Array<any>);
+      // $FlowExpectedError
+      (error.graphQLErrors: string);
+      (error.networkError: Error | null);
+      const extraInfo = error.extraInfo;
+    }
+  });
+  it('handles error state correctly', () => {
+    (loading: boolean);
+    // $FlowExpectedError
+    (loading: string);
+  });
+});
+
+describe('useMutation hook', () => {
+  type TData = {|
+    a: string,
+    b: string,
+  |};
+  type TVariables = {|
+    c: string,
+  |};
+  const [mutation, result] = useMutation<TData, TVariables>('test');
+
+  const { data, loading, error } = result;
+  it('handles data correctly', () => {
+    if (data) {
+      const a: string = data.a;
+      // $FlowExpectedError
+      const b: number = data.b;
+    }
+  });
+  it('handles variables correctly', async () => {
+    // $FlowExpectedError
+    const mutationResult = await mutation({
+      variables: {
+        c: 'test',
+      },
+    });
+    if (mutationResult.data) {
+      (mutationResult.data.a: string);
+      (mutationResult.data.b: string);
+      (mutationResult.data.b: number);
+    }
+    // $FlowExpectedError
+    mutation('', {});
+    // $FlowExpectedError
+    mutation('', {
+      variables: {
+        c: 5,
+      },
+    });
+  });
+  it('handles loading state correctly', () => {
+    if (error) {
+      (error.message: string);
+      (error.graphQLErrors: Array<any>);
+      // $FlowExpectedError
+      (error.graphQLErrors: string);
+      (error.networkError: Error | null);
+      const extraInfo = error.extraInfo;
+    }
+  });
+  it('handles error state correctly', () => {
+    (loading: boolean);
+    // $FlowExpectedError
+    (loading: string);
+  });
+  it('can manually update the cache after a mutation using update on the mutation function', async () => {
+    const mutationResult = await mutation({
+      variables: {
+        c: 'test'
+      },
+      update: cache => {
+        cache.readQuery({ query: 'test' })
+        cache.readQuery<string, number>({ query: 'test' })
+        // $FlowExpectedError
+        cache.readQuery<string>({ query: 'test' })
+      }
+    });
+  })
+});
diff --git a/definitions/npm/@koa/cors_v3.x.x/flow_v0.53.x-/cors_v3.x.x.js b/definitions/npm/@koa/cors_v3.x.x/flow_v0.201.x-/cors_v3.x.x.js
similarity index 100%
rename from definitions/npm/@koa/cors_v3.x.x/flow_v0.53.x-/cors_v3.x.x.js
rename to definitions/npm/@koa/cors_v3.x.x/flow_v0.201.x-/cors_v3.x.x.js
diff --git a/definitions/npm/@koa/cors_v3.x.x/flow_v0.53.x-v0.200.x/cors_v3.x.x.js b/definitions/npm/@koa/cors_v3.x.x/flow_v0.53.x-v0.200.x/cors_v3.x.x.js
new file mode 100644
index 0000000000..a176faa585
--- /dev/null
+++ b/definitions/npm/@koa/cors_v3.x.x/flow_v0.53.x-v0.200.x/cors_v3.x.x.js
@@ -0,0 +1,19 @@
+declare module '@koa/cors' {
+  declare type Middleware = (
+    ctx: any,
+    next: () => Promise<void>
+  ) => Promise<void> | void;
+  declare type Options = $Shape<{|
+    // TODO better support the "function" use case.
+    // This is a bit painful to type this object from scratch.
+    origin: string | ((ctx: any) => string | Promise<string>),
+    allowMethods: string | string[],
+    exposeHeaders: string | string[],
+    allowHeaders: string | string[],
+    maxAge: string | number,
+    credentials: boolean,
+    keepHeadersOnError: boolean,
+  |}>;
+
+  declare module.exports: (options?: Options) => Middleware;
+}
diff --git a/definitions/npm/@koa/router_v8.0.x/flow_v0.84.x-/router_v8.0.x.js b/definitions/npm/@koa/router_v8.0.x/flow_v0.201.x-/router_v8.0.x.js
similarity index 100%
rename from definitions/npm/@koa/router_v8.0.x/flow_v0.84.x-/router_v8.0.x.js
rename to definitions/npm/@koa/router_v8.0.x/flow_v0.201.x-/router_v8.0.x.js
diff --git a/definitions/npm/@koa/router_v8.0.x/flow_v0.84.x-v0.200.x/router_v8.0.x.js b/definitions/npm/@koa/router_v8.0.x/flow_v0.84.x-v0.200.x/router_v8.0.x.js
new file mode 100644
index 0000000000..492286504c
--- /dev/null
+++ b/definitions/npm/@koa/router_v8.0.x/flow_v0.84.x-v0.200.x/router_v8.0.x.js
@@ -0,0 +1,119 @@
+declare module "@koa/router" {
+  declare type Middleware = (
+    ctx: any,
+    next: () => Promise<void>
+  ) => Promise<void> | void;
+
+  declare type ParamMiddleware = (
+    param: string,
+    ctx: any,
+    next: () => Promise<void>
+  ) => Promise<void> | void;
+
+  declare class Router {
+    constructor(opts?: $Shape<{|
+      +prefix: string,
+      +sensitive: boolean,
+      +strict: boolean,
+      +methods: Array<string>,
+    |}>): Router;
+
+    get(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    get(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    patch(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    patch(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    post(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    post(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    put(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    put(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    delete(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    delete(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    del(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    del(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    all(
+      name: string,
+      route: string | string[],
+      handler: Middleware
+    ): this;
+    all(
+      route: string | string[],
+      ...middleware: Array<Middleware>
+    ): this;
+
+    use(...middleware: Array<Middleware>): this;
+    use(
+      path: string | Array<string>,
+      ...middleware: Array<Middleware>
+    ): this;
+
+    prefix(prefix: string): this;
+
+    routes(): Middleware;
+
+    allowedMethods(options?: $Shape<{|
+      +throw: boolean,
+      +notImplemented: () => any,
+      +methodNotAllowed: () => any,
+    |}>): Middleware;
+
+    param(param: string, middleware: ParamMiddleware): this;
+
+    redirect(source: string, destination: string, code?: number): this;
+
+    route(name: string): any | false;
+
+    url(name: string, params: { ... }, options?: {| query: { ... } | string |}): string | Error;
+
+    static url(path: string, params: { ... }): string;
+  }
+
+  declare module.exports: typeof Router;
+}
diff --git a/definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-/router_v1.1.x.js b/definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-v0.200.x/router_v1.1.x.js
similarity index 100%
rename from definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-/router_v1.1.x.js
rename to definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-v0.200.x/router_v1.1.x.js
diff --git a/definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-/test_router_v1.1.x.js b/definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-v0.200.x/test_router_v1.1.x.js
similarity index 100%
rename from definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-/test_router_v1.1.x.js
rename to definitions/npm/@reach/router_v1.1.x/flow_v0.104.x-v0.200.x/test_router_v1.1.x.js
diff --git a/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/router_v1.1.x.js b/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/router_v1.1.x.js
new file mode 100644
index 0000000000..aa9a184020
--- /dev/null
+++ b/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/router_v1.1.x.js
@@ -0,0 +1,135 @@
+// @flow
+
+declare module '@reach/router' {
+  declare type DomLocation = typeof location & {| state?: any |};
+
+  declare export type NavigateFn = (
+    to: string,
+    options?: NavigateOptions<{...}>
+  ) => void;
+
+  declare export var navigate: NavigateFn;
+
+  declare export type HistoryListener = () => void;
+
+  declare export type HistoryUnlistener = () => void;
+
+  declare export interface History {
+    location: string;
+    transitioning: boolean;
+    listen: (listener: HistoryListener) => HistoryUnlistener;
+    navigate: NavigateFn;
+  }
+
+  declare export interface HistorySource {
+    location: DomLocation;
+    addEventListener(name: string, listener: (event: Event) => void): void;
+    removeEventListener(name: string, listener: (event: Event) => void): void;
+
+    history: {
+      state: any,
+      pushState(state: any, title: string, uri: string): void,
+      replaceState(state: any, title: string, uri: string): void,
+      ...
+    };
+  }
+
+  declare export interface NavigateOptions<State> {
+    state?: State;
+    replace?: boolean;
+  }
+
+  declare type CommonRouteProps = {|
+    children?: React$Node,
+    location?: DomLocation,
+    navigate?: NavigateFn,
+    uri?: string,
+  |};
+
+  declare export type DefaultRouteProps = {
+    ...CommonRouteProps,
+    default: boolean,
+    ...
+  };
+
+  declare export type RouteProps = {
+    ...CommonRouteProps,
+    path: string,
+    ...
+  };
+
+  declare export type LocationProviderRenderFn = (context: {|
+    location: DomLocation,
+    navigate: NavigateFn,
+  |}) => React$Node;
+
+  declare export var Router: React$StatelessFunctionalComponent<{|
+    children?: React$Node,
+    basepath?: string,
+    primary?: boolean,
+    location?: DomLocation,
+  |}>;
+
+  declare export type LinkProps<State> = {
+    ...$Shape<HTMLAnchorElement>,
+    children: React$Node,
+    innerRef?: React$Ref<HTMLAnchorElement>,
+    getProps?: (props: {
+      isCurrent: boolean,
+      isPartiallyCurrent: boolean,
+      href: string,
+      location: DomLocation,
+      ...
+    }) => {...},
+    state?: State,
+    to?: string,
+    replace?: boolean,
+    // remove href, as it's ignored by the router
+    href?: empty,
+    ...
+  };
+
+  declare export var Link: { <State>(props: LinkProps<State>): React$Node, ... };
+
+  declare export var Redirect: React$StatelessFunctionalComponent<{|
+    from?: string,
+    to: string,
+    noThrow?: boolean,
+    state?: any
+  |}>;
+
+  declare export type MatchProps<Params> = {|
+    path: string,
+    children: (props: {|
+      match: null | {| uri: string, path: string, ...$Exact<Params> |},
+      location: DomLocation,
+      navigate: NavigateFn,
+    |}) => React$Node,
+  |};
+
+  declare export var Match: { <Params>(props: MatchProps<Params>): React$Node, ... };
+
+  declare export var Location: React$StatelessFunctionalComponent<{|
+    children: LocationProviderRenderFn,
+  |}>;
+
+  declare export class LocationProvider extends React$Component<{|
+    history: History,
+    children?: React$Node | LocationProviderRenderFn,
+  |}> {}
+
+  declare export var ServerLocation: React$StatelessFunctionalComponent<{|
+    url: string,
+    children?: React$Node,
+  |}>;
+
+  declare export function createHistory(source: HistorySource): History;
+
+  declare export function createMemorySource(
+    initialPath: string
+  ): HistorySource;
+
+  declare export function isRedirect(error: any): $Exact<{ uri: string, ... }>;
+
+  declare export function redirectTo(uri: string): void;
+}
diff --git a/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/test_router_v1.1.x.js b/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/test_router_v1.1.x.js
new file mode 100644
index 0000000000..cb986ee09a
--- /dev/null
+++ b/definitions/npm/@reach/router_v1.1.x/flow_v0.201.x-/test_router_v1.1.x.js
@@ -0,0 +1,273 @@
+// @flow
+import * as React from 'react';
+
+import {
+  Router,
+  Link,
+  Redirect,
+  Match,
+  navigate,
+  Location,
+  LocationProvider,
+  ServerLocation,
+  createHistory,
+  createMemorySource,
+  isRedirect,
+  redirectTo,
+  type MatchProps,
+  type LinkProps,
+} from '@reach/router';
+
+import type { DefaultRouteProps, RouteProps } from '@reach/router';
+
+import { it, describe } from 'flow-typed-test';
+
+describe('@reach/router', () => {
+  describe('Router', () => {
+    it('works', () => {
+      <Router basepath="/" primary={true}>
+        <div />
+      </Router>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - basepath must be a string
+      <Router basepath={{}} />;
+      // $FlowExpectedError - primary must be a boolean
+      <Router primary={{}} />;
+      // $FlowExpectedError - children must be a React$Node
+      <Router>{Array}</Router>;
+    });
+  });
+
+  describe('DefaultRoute', () => {
+    const DefaultRoute = (props: DefaultRouteProps) => <div {...props} />;
+
+    it('works', () => {
+      <DefaultRoute default />;
+      <DefaultRoute default>
+        <div />
+      </DefaultRoute>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - default must be a boolean
+      <DefaultRoute default={{}} />;
+      // $FlowExpectedError - children must be a React$Node
+      <DefaultRoute default>{Array}</DefaultRoute>;
+    });
+  });
+
+  describe('Route', () => {
+    const Route = (props: RouteProps) => <div {...props} />;
+
+    it('works', () => {
+      <Route path="/" />;
+      <Route path="invoice/:invoiceId" />;
+      <Route path="admin/*" />;
+      <Route path="" custom />;
+      <Route path="/">
+        <div />
+      </Route>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - path must be a string
+      <Route path={{}} />;
+      // $FlowExpectedError - children must be a React$Node
+      <Route path="/">{Array}</Route>;
+    });
+  });
+
+  describe('Link', () => {
+    it('works', () => {
+      <Link to="/" replace custom>
+        <div />
+      </Link>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - children must be a React$Node
+      <Link to="/">{Array}</Link>;
+      // $FlowExpectedError - to must be a string
+      <Link to={{}} />;
+      // $FlowExpectedError - href isn't available
+      <Link href="/" />;
+    });
+  });
+
+  describe('Redirect', () => {
+    it('works', () => {
+      <Redirect from="aboutus" to="about-us" />;
+      <Redirect from="users/:userId" to="profile/:userId" />;
+      <Redirect to="/" noThrow />;
+      <Redirect to="/state" state={{srcUrl: '/'}} />;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - from must be a string
+      <Redirect from={{}} to="/" />;
+      // $FlowExpectedError - to must be a string
+      <Redirect to={{}} />;
+      // $FlowExpectedError - noThrow must be a boolean
+      <Redirect to="/" noThrow="" />;
+    });
+  });
+
+  describe('Match', () => {
+    it('works', () => {
+      <Match path="/">
+        {props =>
+          props.match ? <div>Hot {props.match.item}</div> : <div>Uncool</div>
+        }
+      </Match>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - children must be a function
+      <Match>
+        <div />
+      </Match>;
+    });
+
+    describe('generic magic', () => {
+      type Params = {
+        articleId: string,
+        commentId: string,
+        ...
+      };
+
+      /*
+      In the future (https://github.com/facebook/flow/issues/7672) we can use this syntax:
+
+      <Match<Params>>
+        {props => {
+          if (props.match) {
+            (props.match.articleId: string);
+          }
+        }}
+      </Match>;
+
+      But now you need to create a wrapper with a type definition:
+
+      */
+      const MatchItem = (props: MatchProps<Params>) => Match<Params>(props);
+
+      it('should define more pure type for match prop', () => {
+        <MatchItem path="/:articleId/:commentId">
+          {props => {
+            if (props.match) {
+              (props.match.articleId: string);
+              (props.match.commentId: string);
+
+              // $FlowExpectedError - `match` is exact type
+              (props.match.abc: number);
+              // $FlowExpectedError - `articleId` prop must be string
+              (props.match.articleId: boolean);
+
+              return <div>Cool</div>;
+            }
+
+            return <div>Uncool</div>;
+          }}
+        </MatchItem>;
+      });
+    });
+  });
+
+  describe('navigate', () => {
+    it('works', () => {
+      navigate('/');
+      navigate('/', { state: {}, redirect: true });
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - first param must be a string
+      navigate({});
+    });
+  });
+
+  describe('Location', () => {
+    it('works', () => {
+      <Location>{props => <div />}</Location>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - children must be a function
+      <Location>
+        <div />
+      </Location>;
+    });
+  });
+
+  describe('LocationProvider', () => {
+    it('works', () => {
+      const history = createHistory(window);
+
+      <LocationProvider history={history}>
+        <div>Alright, we've established some location context</div>
+      </LocationProvider>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - history must be an instance of History
+      <LocationProvider history={{}}>
+        <div>Alright, we've established some location context</div>
+      </LocationProvider>;
+    });
+  });
+
+  describe('ServerLocation', () => {
+    it('works', () => {
+      <ServerLocation url="/groups/123">
+        <div />
+      </ServerLocation>;
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - url must be a string
+      <ServerLocation url={{}}>
+        <div />
+      </ServerLocation>;
+    });
+  });
+
+  describe('createHistory', () => {
+    it('works', () => {
+      createHistory(window);
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - first param must implements HistorySource
+      createHistory({});
+    });
+  });
+
+  describe('createMemorySource', () => {
+    it('works', () => {
+      createMemorySource('/starting/url');
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - first param must be a string
+      createMemorySource({});
+    });
+  });
+
+  describe('isRedirect', () => {
+    it('works', () => {
+      isRedirect({});
+    });
+  });
+
+  describe('redirectTo', () => {
+    it('works', () => {
+      redirectTo('/');
+    });
+
+    it('raises error', () => {
+      // $FlowExpectedError - first param must be a string
+      redirectTo({});
+    });
+  });
+});
diff --git a/definitions/npm/@react-navigation/core_v3.x.x/flow_v0.104.x-/core_v3.x.x.js b/definitions/npm/@react-navigation/core_v3.x.x/flow_v0.104.x-v0.200.x/core_v3.x.x.js
similarity index 100%
rename from definitions/npm/@react-navigation/core_v3.x.x/flow_v0.104.x-/core_v3.x.x.js
rename to definitions/npm/@react-navigation/core_v3.x.x/flow_v0.104.x-v0.200.x/core_v3.x.x.js
diff --git a/definitions/npm/@react-navigation/core_v3.x.x/flow_v0.201.x-/core_v3.x.x.js b/definitions/npm/@react-navigation/core_v3.x.x/flow_v0.201.x-/core_v3.x.x.js
new file mode 100644
index 0000000000..406b7a7ea4
--- /dev/null
+++ b/definitions/npm/@react-navigation/core_v3.x.x/flow_v0.201.x-/core_v3.x.x.js
@@ -0,0 +1,948 @@
+// @flow
+
+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.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 1A
+   * 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;
+
+  /**
+   * SECTION 1B
+   * The following are type declarations for core types necessary for every
+   * React Navigation libdef.
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+    +toChildKey?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationJumpToAction = {|
+    +type: 'Navigation/JUMP_TO';
+    +preserveFocus: boolean,
+    +routeName: string,
+    +key?: string,
+    +params?: NavigationParams,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction
+    | NavigationJumpToAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<NavigationState>,
+  |};
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenProps = { [key: string]: mixed, ... };
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: ?NavigationScreenProps,
+    theme: SupportedThemes,
+  ) => 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 NavigationScreenOptions = { title?: string, ... };
+
+  declare export type SupportedThemes = 'light' | 'dark';
+
+  declare export type NavigationScreenConfigProps = $Shape<{|
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: NavigationScreenProps,
+    theme: SupportedThemes,
+  |}>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({|
+        ...NavigationScreenConfigProps,
+        navigationOptions: Options,
+      |}) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare type _NavigationRouteConfigCore = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    params?: NavigationParams,
+    path?: string,
+  |};
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | {| ..._NavigationRouteConfigCore, screen: NavigationComponent |}
+    | {| ..._NavigationRouteConfigCore, getScreen: () => NavigationComponent |};
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    goBack: (routeKey?: ?string) => boolean,
+    dismiss: () => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+            routeName: string,
+            params?: NavigationParams,
+            action?: NavigationNavigateAction,
+            key?: string,
+            ...
+          },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    theme?: SupportedThemes | 'no-preference',
+    detached?: boolean,
+    ...
+  }>;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationDescriptor
+   */
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    getComponent: () => NavigationComponent,
+    ...
+  };
+
+  declare export type NavigationDescriptorMap = {
+    [key: string]: NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: SHARED TYPE DEFINITIONS
+  // This section too is copy-pasted, but it's not identical across all React
+  // Navigation libdefs. We pick out bits and pieces that we need.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 2A
+   * We start with definitions we have copy-pasted, either from in-package
+   * types, other Flow libdefs, or from TypeScript types somewhere.
+   */
+
+  // This is 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 class AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // This is copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare class Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare class AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare class 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;
+  }
+
+  /**
+   * SECTION 2B
+   * The following are the actually useful definitions in Section 2, that are
+   * used below in section 3, but also in other libdefs.
+   */
+
+  declare export type NavigationPathsConfig = { [routeName: string]: string, ... };
+
+  /**
+   * SafeAreaView
+   */
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewInsets = $Shape<{|
+    top: _SafeAreaViewForceInsetValue,
+    bottom: _SafeAreaViewForceInsetValue,
+    left: _SafeAreaViewForceInsetValue,
+    right: _SafeAreaViewForceInsetValue,
+    vertical: _SafeAreaViewForceInsetValue,
+    horizontal: _SafeAreaViewForceInsetValue,
+  |}>;
+
+  /**
+   * Interpolation
+   */
+
+  declare export type NavigationStackInterpolatorProps = $Shape<{|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode?: HeaderMode,
+    shadowEnabled?: boolean,
+    cardOverlayEnabled?: boolean,
+  |}>;
+
+  declare type _InterpolationResult = { [key: string]: mixed, ... };
+  declare export type NavigationStackInterpolator =
+    (props: NavigationStackInterpolatorProps) => _InterpolationResult;
+
+  /**
+   * Header
+   */
+
+  declare export type HeaderMode = 'float' | 'screen' | 'none';
+
+  declare export type HeaderProps = {|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode: HeaderMode,
+    leftInterpolator?: NavigationStackInterpolator,
+    titleInterpolator?: NavigationStackInterpolator,
+    rightInterpolator?: NavigationStackInterpolator,
+    backgroundInterpolator?: NavigationStackInterpolator,
+    layoutPreset: 'left' | 'center',
+    transitionPreset?: 'fade-in-place' | 'uikit',
+    backTitleVisible?: boolean,
+    isLandscape: boolean,
+  |};
+
+  /**
+   * StackRouter
+   */
+
+  declare export type NavigationStackProp<+S> =
+    & NavigationScreenProp<S>
+    & {
+        pop: (n?: number, params?: {| immediate?: boolean |}) => boolean,
+        popToTop: (params?: {| immediate?: boolean |}) => boolean,
+        push: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        replace: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        reset: (actions: NavigationAction[], index: number) => boolean,
+        ...
+      };
+
+  declare type _HeaderBackButtonProps = {|
+    disabled?: boolean,
+    onPress: () => void,
+    pressColorAndroid?: string,
+    tintColor?: ?string,
+    backImage?: React$ComponentType<{
+      tintColor: string,
+      title?: ?string,
+      ...
+    }>,
+    title?: ?string,
+    truncatedTitle?: ?string,
+    backTitleVisible?: boolean,
+    allowFontScaling?: boolean,
+    titleStyle?: ?TextStyleProp,
+    headerLayoutPreset: 'left' | 'center',
+    width?: ?number,
+    scene: NavigationStackScene,
+  |};
+
+  declare export type NavigationStackScreenOptions = NavigationScreenOptions & {
+    header?: ?(React$Node | (HeaderProps => React$Node)),
+    headerTransparent?: boolean,
+    headerTitle?: (props: { children: ?string, ... }) => React$Node | React$Node,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: ((props: _HeaderBackButtonProps) => React$Node) | React$Node,
+    headerBackTitle?: ?string,
+    headerBackImage?: (props: {|
+      tintColor?: string,
+      title?: ?string,
+    |}) => React$Node,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: React$Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: _SafeAreaViewInsets,
+    headerBackground?: React$Node | React$ElementType,
+    gesturesEnabled?: boolean,
+    gestureResponseDistance?: {|
+      vertical?: number,
+      horizontal?: number,
+    |},
+    gestureDirection?: 'default' | 'inverted',
+    ...
+  };
+
+  declare export type NavigationStackRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    initialRouteKey?: string,
+  |};
+
+  /**
+   * Stack Gestures, Animations, and Interpolators
+   */
+
+  declare export type NavigationStackLayout = {
+    height: AnimatedValue,
+    initHeight: number,
+    initWidth: number,
+    isMeasured: boolean,
+    width: AnimatedValue,
+    ...
+  };
+
+  declare export type NavigationStackScene = {
+    index: number,
+    isActive: boolean,
+    isStale: boolean,
+    key: string,
+    route: NavigationRoute,
+    descriptor: ?NavigationDescriptor,
+    ...
+  };
+
+  /**
+   * SwitchRouter
+   */
+
+  declare export type NavigationSwitchRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    // todo: type these as the real route names rather than 'string'
+    order?: string[],
+    // Does the back button cause the router to switch to the initial tab
+    backBehavior?: 'none' | 'initialRoute' | 'history' | 'order', // defaults `initialRoute`
+    resetOnBlur?: boolean,
+  |};
+
+  /**
+   * TabRouter
+   */
+
+  declare export type NavigationTabProp<+S> =
+    & NavigationScreenProp<S>
+    & { jumpTo: (routeName: string, key?: string) => void, ... };
+
+  declare export type NavigationTabRouterConfig = NavigationSwitchRouterConfig;
+
+  declare export type NavigationTabScreenOptions = {
+    ...$Exact<NavigationScreenOptions>,
+    tabBarLabel?: React$Node,
+    tabBarVisible?: boolean,
+    tabBarAccessibilityLabel?: string,
+    tabBarTestID?: string,
+    tabBarIcon?:
+      | React$Node
+      | ((props: {|
+          focused: boolean,
+          tintColor?: string,
+          horizontal?: boolean,
+        |}) => React$Node),
+    tabBarOnPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    tabBarOnLongPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 3: UNIQUE TYPE DEFINITIONS
+  // This section normally contains exported types that are not present in any
+  // other React Navigation libdef. But the main react-navigation libdef doesn't
+  // have any, so it's empty here.
+  //---------------------------------------------------------------------------
+
+  //---------------------------------------------------------------------------
+  // SECTION 4: EXPORTED MODULE
+  // This is the only section that types exports. Other sections export types,
+  // but this section types the module's exports.
+  //---------------------------------------------------------------------------
+
+  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 getNavigation<State: NavigationState, Options: {...}>(
+    router: NavigationRouter<State, Options>,
+    state: State,
+    dispatch: NavigationDispatch,
+    actionSubscribers: Set<NavigationEventCallback>,
+    getScreenProps: () => {...},
+    getCurrentNavigation: () => ?NavigationScreenProp<State>
+  ): NavigationScreenProp<State>;
+
+  declare type _NavigationView<O, S, N: NavigationScreenProp<S>> = React$ComponentType<{
+    descriptors: NavigationDescriptorMap,
+    navigation: N,
+    navigationConfig: any,
+    ...
+  }>;
+  declare export function createNavigator<O: any, S: any, NavigatorConfig: any, N: NavigationScreenProp<S>>(
+    view: _NavigationView<O, S, N>,
+    router: NavigationRouter<S, O>,
+    navigatorConfig?: NavigatorConfig
+  ): NavigationNavigator<S, O, any>;
+
+  declare export var NavigationContext: React$Context<
+    ?NavigationScreenProp<NavigationState | NavigationRoute>,
+  >;
+  declare export var NavigationProvider: $PropertyType<typeof NavigationContext, 'Provider'>;
+  declare export var NavigationConsumer: $PropertyType<typeof NavigationContext, 'Consumer'>;
+
+  declare type _SwitchNavigatorConfig = NavigationSwitchRouterConfig;
+  declare export function createSwitchNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _SwitchNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare export var ThemeContext: React$Context<SupportedThemes>;
+  declare export var ThemeProvider: $PropertyType<typeof ThemeContext, 'Provider'>;
+  declare export var ThemeConsumer: $PropertyType<typeof ThemeContext, 'Consumer'>;
+  declare export var ThemeColors: { [theme: SupportedThemes]: { [key: string]: string, ... }, ... };
+  declare export function useTheme(): SupportedThemes;
+
+  declare export var NavigationActions: {|
+    BACK: 'Navigation/BACK',
+    INIT: 'Navigation/INIT',
+    NAVIGATE: 'Navigation/NAVIGATE',
+    SET_PARAMS: 'Navigation/SET_PARAMS',
+    back: (payload?: {| key?: ?string |}) => NavigationBackAction,
+    init: (payload?: {| params?: NavigationParams |}) => NavigationInitAction,
+    navigate: (payload: {|
+      routeName: string,
+      params?: ?NavigationParams,
+      action?: ?NavigationNavigateAction,
+      key?: string,
+    |}) => NavigationNavigateAction,
+    setParams: (payload: {|
+      key: string,
+      params: NavigationParams,
+    |}) => NavigationSetParamsAction,
+  |};
+
+  declare export var StackActions: {|
+    POP: 'Navigation/POP',
+    POP_TO_TOP: 'Navigation/POP_TO_TOP',
+    PUSH: 'Navigation/PUSH',
+    RESET: 'Navigation/RESET',
+    REPLACE: 'Navigation/REPLACE',
+    COMPLETE_TRANSITION: 'Navigation/COMPLETE_TRANSITION',
+    pop: (payload: {|
+      n?: number,
+      immediate?: boolean,
+    |}) => NavigationPopAction,
+    popToTop: (payload: {|
+      immediate?: boolean,
+      key?: string,
+    |}) => NavigationPopToTopAction,
+    push: (payload: {|
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      key?: string,
+    |}) => NavigationPushAction,
+    reset: (payload: {|
+      index: number,
+      key?: ?string,
+      actions: Array<NavigationNavigateAction>,
+    |}) => NavigationResetAction,
+    replace: (payload: {|
+      key?: string,
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+    |}) => NavigationReplaceAction,
+    completeTransition: (payload: {|
+      key?: string,
+      toChildKey?: string,
+    |}) => NavigationCompleteTransitionAction,
+  |};
+
+  declare export var SwitchActions: {|
+    JUMP_TO: 'Navigation/JUMP_TO',
+    jumpTo: (payload: {|
+      routeName: string,
+      key?: string,
+      params?: NavigationParams,
+    |}) => NavigationJumpToAction,
+  |};
+
+  declare export function StackRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationStackRouterConfig
+  ): NavigationRouter<any, NavigationStackScreenOptions>;
+
+  declare export function TabRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: NavigationTabRouterConfig
+  ): NavigationRouter<any, NavigationTabScreenOptions>;
+
+  declare export function SwitchRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationSwitchRouterConfig
+  ): NavigationRouter<any, {| |}>;
+
+  declare export function getActiveChildNavigationOptions<
+    State: NavigationState,
+    Options: {...}
+  >(
+    navigation: NavigationScreenProp<State>,
+    screenProps?: NavigationScreenProps,
+    theme?: SupportedThemes,
+  ): Options;
+
+  declare type _SceneViewProps = {
+    component: React$ComponentType<{
+      screenProps: ?NavigationScreenProps,
+      navigation: NavigationScreenProp<NavigationRoute>,
+      ...
+    }>,
+    screenProps: ?NavigationScreenProps,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    ...
+  };
+  declare export var SceneView: React$ComponentType<_SceneViewProps>;
+
+  declare type _NavigationEventsProps = {
+    navigation?: NavigationScreenProp<NavigationState>,
+    onWillFocus?: NavigationEventCallback,
+    onDidFocus?: NavigationEventCallback,
+    onWillBlur?: NavigationEventCallback,
+    onDidBlur?: NavigationEventCallback,
+    ...
+  };
+  declare export var NavigationEvents: React$ComponentType<
+    _NavigationEventsProps
+  >;
+
+  declare export function withNavigation<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<
+    $Diff<
+      React$ElementConfig<ComponentType>,
+      {| navigation: NavigationScreenProp<NavigationStateRoute> |}
+    >
+  >;
+  declare export function withNavigationFocus<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<$Diff<React$ElementConfig<ComponentType>, {| isFocused: ?boolean |}>>;
+
+}
diff --git a/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-/react-ui_v1.x.x.js b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-v0.200.x/react-ui_v1.x.x.js
similarity index 100%
rename from definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-/react-ui_v1.x.x.js
rename to definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-v0.200.x/react-ui_v1.x.x.js
diff --git a/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-/test_react-ui_v1.x.x.js b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-v0.200.x/test_react-ui_v1.x.x.js
similarity index 100%
rename from definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-/test_react-ui_v1.x.x.js
rename to definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.104.x-v0.200.x/test_react-ui_v1.x.x.js
diff --git a/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/react-ui_v1.x.x.js b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/react-ui_v1.x.x.js
new file mode 100644
index 0000000000..40a7384481
--- /dev/null
+++ b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/react-ui_v1.x.x.js
@@ -0,0 +1,2835 @@
+/* @flow */
+/* eslint-disable max-len */
+
+type InputEventHandler<E: Element> = (event: SyntheticInputEvent<E>) => void;
+
+type FocusEventHandler<E: Element> = (event: SyntheticFocusEvent<E>) => void;
+
+type MouseEventHandler<E: Element> = (event: SyntheticMouseEvent<E>) => void;
+
+type KeyboardEventHandler<E: Element> = (
+  event: SyntheticKeyboardEvent<E>,
+) => void;
+
+type InputSize = 'small' | 'medium' | 'large';
+type InputAlign = 'left' | 'center' | 'right';
+type InputType = 'password' | 'text';
+type IconType = React$Node | (() => React$Node);
+
+type AnyObject<T> = {
+  +[key: string]: T,
+  ...,
+};
+
+type _Theme = AnyObject<string>;
+
+type _InputProps = {
+  leftIcon?: IconType,
+  rightIcon?: IconType,
+  error?: boolean,
+  warning?: boolean,
+  borderless?: boolean,
+  align?: InputAlign,
+  mask?: ?string,
+  maskChar?: ?string,
+  formatChars?: AnyObject<string>,
+  alwaysShowMask?: boolean,
+  size?: InputSize,
+  onChange?: (
+    event: SyntheticKeyboardEvent<HTMLInputElement>,
+    value: string,
+  ) => void,
+  onMouseEnter?: MouseEventHandler<HTMLLabelElement>,
+  onMouseLeave?: MouseEventHandler<HTMLLabelElement>,
+  onMouseOver?: MouseEventHandler<HTMLLabelElement>,
+  type?: InputType,
+  value?: string,
+  capture?: boolean,
+  prefix?: React$Node,
+  suffix?: React$Node,
+  mainInGroup?: boolean,
+  selectAllOnFocus?: boolean,
+  onUnexpectedInput?: () => void,
+  ...
+};
+
+type _MenuItemState = null | 'hover' | 'selected' | void;
+
+declare class _MenuItem extends React$Component<_MenuItemProps> {
+  static __MENU_ITEM__: boolean;
+  static __MENU_HEADER__: boolean;
+}
+
+type _InputVisibilityState = {|
+  blinking: boolean,
+  focused: boolean,
+|};
+
+type _InputState = {|
+  ...$Exact<_InputVisibilityState>,
+  polyfillPlaceholder: boolean,
+|};
+
+type Style = AnyObject<string | number>;
+
+declare class _Input extends React$Component<_InputProps, _InputState> {
+  focus(): void;
+  blur(): void;
+  blink(): void;
+  setSelectionRange(start: number, end: number): void;
+  selectAll: () => void;
+}
+
+type _MenuProps = {|
+  children: React$Node,
+  hasShadow?: boolean,
+  maxHeight?: number | string,
+  onItemClick?: () => void,
+  width?: number | string,
+  preventWindowScroll?: boolean,
+|};
+
+type _MenuState = {|
+  highlightedIndex: number,
+|};
+
+declare class _Menu extends React$Component<_MenuProps, _MenuState> {
+  up(): void;
+  down(): void;
+  enter(event: SyntheticEvent<HTMLElement>): boolean;
+  reset(): void;
+  highlightItem(index: number): void;
+}
+
+type InputLikeTextProps = {|
+  ...$Exact<_InputProps>,
+  children?: React$Node,
+  innerRef?: (el: HTMLElement | null) => void,
+  onFocus?: FocusEventHandler<HTMLElement>,
+  onBlur?: FocusEventHandler<HTMLElement>,
+|};
+
+type InputLikeTextState = {|
+  ...$Exact<_InputVisibilityState>,
+|};
+
+declare class _InputLikeText extends React$Component<
+  InputLikeTextProps,
+  InputLikeTextState,
+> {
+  focus(): void;
+  blur(): void;
+  blink(): void;
+}
+
+type _CalendarDateShape = {|
+  year: number,
+  month: number,
+  date: number,
+|};
+
+declare class _MenuHeader extends React$Component<_MenuHeaderProps> {
+  static __MENU_HEADER__: boolean;
+}
+
+type MenuSeparatorProps = {||};
+
+declare class _MenuSeparator extends React$Component<MenuSeparatorProps> {}
+
+type _ButtonSize = 'small' | 'medium' | 'large';
+type _ButtonType = 'button' | 'submit' | 'reset';
+type _ButtonArrow = boolean | 'left';
+type _ButtonUse = 'default' | 'primary' | 'success' | 'danger' | 'pay' | 'link';
+
+type _PopupMenuCaptionProps = {|
+  opened: boolean,
+  openMenu: (firstItemShouldBeSelected?: boolean) => void,
+  closeMenu: (restoreFocus?: boolean) => void,
+  toggleMenu: () => void,
+|};
+
+type _PopupMenuProps = {|
+  children?: React$Node,
+  menuMaxHeight?: number | string,
+  menuWidth?: number | string,
+  caption: React$Node | ((props: _PopupMenuCaptionProps) => React$Node),
+  positions?: $ReadOnlyArray<string>,
+  onChangeMenuState?: (isOpened: boolean, restoreFocus: boolean) => void,
+  popupHasPin?: boolean,
+  popupMargin?: number,
+  popupPinOffset?: number,
+  type?: 'dropdown' | 'tooltip',
+  disableAnimations: boolean,
+|};
+
+type _PopupPosition =
+  | 'top left'
+  | 'top center'
+  | 'top right'
+  | 'right top'
+  | 'right middle'
+  | 'right bottom'
+  | 'bottom left'
+  | 'bottom center'
+  | 'bottom right'
+  | 'left top'
+  | 'left middle'
+  | 'left bottom';
+
+type _SyntheticRadioEvent<T> = {|
+  target: {|
+    id: ?string,
+    name: ?string,
+    checked: ?boolean,
+    disabled: ?boolean,
+    value: T,
+  |},
+|};
+
+type _TokenColorName = string;
+
+type _TokenColors = {|
+  idle: _TokenColorName,
+  active?: _TokenColorName,
+|};
+
+type _TokenProps = {|
+  colors?: _TokenColors,
+  isActive?: boolean,
+  error?: boolean,
+  warning?: boolean,
+|};
+
+type _MenuHeaderProps = {|
+  children: React$Node,
+  _enableIconPadding?: ?boolean,
+|};
+
+type _MenuItemProps = {|
+  _enableIconPadding?: boolean,
+  alkoLink?: boolean,
+  comment?: React$Node,
+  disabled?: boolean,
+  // eslint-disable-next-line flowtype/no-weak-types
+  icon?: React$Element<any>,
+  loose?: boolean,
+  state?: _MenuItemState,
+  onClick?: MouseEventHandler<HTMLElement>,
+  children?: React$Node | ((state: _MenuItemState) => React$Node),
+  target?: string,
+  title?: string,
+  href?: string,
+  onMouseEnter?: MouseEventHandler<HTMLElement>,
+  onMouseLeave?: MouseEventHandler<HTMLElement>,
+  // eslint-disable-next-line flowtype/no-weak-types
+  component?: React$ComponentType<any>,
+|};
+
+type _CurrencyInputState = {|
+  formatted: string,
+  selection: Selection,
+  focused: boolean,
+|};
+
+declare class _CurrencyInput extends React$Component<
+  _CurrencyInputProps,
+  _CurrencyInputState,
+> {
+  focus: () => void;
+  blur: () => void;
+}
+
+type _CurrencyInputProps = {
+  value: ?number,
+  fractionDigits?: ?number,
+  signed?: boolean,
+  onChange: (
+    e: {
+      target: {|
+        value: ?number,
+      |},
+      ...
+    },
+    value: ?number,
+  ) => void,
+  onSubmit?: () => void,
+  ...
+};
+
+type _SpinnerType = 'mini' | 'normal' | 'big';
+
+type _SpinnerProps = {|
+  caption?: React$Node,
+  dimmed?: boolean,
+  type?: _SpinnerType,
+|};
+
+type _MAP = {|
+  circle: string,
+  baseline: string,
+  warning: string,
+  ok: string,
+  gear: string,
+  user: string,
+  wait: string,
+  clear: string,
+  grid: string,
+  money: string,
+  'help-circle': string,
+  kebab: string,
+|};
+
+type _IconProps = {|
+  name: $Keys<_MAP>,
+  color: string,
+|};
+
+type _ComboBoxItem = {|
+  value: string | number,
+  label: string,
+|};
+
+type _FiasLocale = {|
+  modalTitle: string,
+  modalButtonOk: string,
+  modalButtonCancel: string,
+
+  addressFill: string,
+  addressEdit: string,
+  addressNotVerified: string,
+  addressNotFound: string,
+  addressFillParentOrSearch: string,
+  addressSelectItemFromList: string,
+
+  searchNotFound: string,
+  searchPlaceholder: string,
+
+  regionLabel: string,
+  regionNotFound: string,
+  regionPlaceholder: string,
+
+  districtLabel: string,
+  districtNotFound: string,
+  districtPlaceholder: string,
+
+  cityLabel: string,
+  cityNotFound: string,
+  cityPlaceholder: string,
+
+  intracityareaLabel: string,
+  intracityareaNotFound: string,
+  intracityareaPlaceholder: string,
+
+  settlementLabel: string,
+  settlementNotFound: string,
+  settlementPlaceholder: string,
+
+  planningstructureLabel: string,
+  planningstructureNotFound: string,
+  planningstructurePlaceholder: string,
+
+  streetLabel: string,
+  streetNotFound: string,
+  streetFillBefore: string,
+  streetPlaceholder: string,
+
+  steadLabel: string,
+  steadNotFound: string,
+  steadFillBefore: string,
+  steadPlaceholder: string,
+
+  houseLabel: string,
+  houseNotFound: string,
+  houseFillBefore: string,
+  housePlaceholder: string,
+
+  roomLabel: string,
+  roomNotFound: string,
+  roomFillBefore: string,
+  roomPlaceholder: string,
+
+  postalcodeLabel: string,
+  postalcodePlaceholder: string,
+  postalcodeNotFound: string,
+  postalcodeNotValid: string,
+  postalcodeReplace: string,
+
+  foreignAddressLabel: string,
+  foreignAddressPlaceholder: string,
+
+  countryLabel: string,
+  countryPlaceholder: string,
+|};
+
+type _LogotypeLocale = {|
+  suffix: string,
+  prefix: string,
+|};
+
+type _ComboBoxLocale = {|
+  notFound: string,
+  errorNetworkButton: string,
+  errorNetworkMessage: string,
+|};
+
+type InternalDateOrder = 'DMY' | 'YMD' | 'MDY';
+
+type InternalDateSeparator = '/' | '.' | '-' | ' ';
+
+type InternalDateFirstDayWeek = 0 | 1 | 2;
+
+type InternalDateDayWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+type InternalDateLocaleSet = {|
+  order: InternalDateOrder,
+  separator: InternalDateSeparator,
+  firstDayWeek: InternalDateFirstDayWeek,
+  notWorkingDays: $ReadOnlyArray<InternalDateDayWeek>,
+|};
+
+type _DatePickerLocale = {|
+  ...$Exact<InternalDateLocaleSet>,
+  today: string,
+  months: $ReadOnlyArray<string>,
+|};
+
+type _PagingLocale = {|
+  forward: string,
+|};
+
+type _SelectLocale = {|
+  placeholder: React$Node,
+|};
+
+type _SpinnerLocale = {|
+  loading: React$Node,
+|};
+
+type _TokenInputLocale = {|
+  addButtonComment: string,
+  addButtonTitle: string,
+|};
+
+type _TopBarLocale = {|
+  logout: string,
+  cabinetTitle: string,
+  cabinetSettings: string,
+  cabinetCertificates: string,
+  cabinetServices: string,
+|};
+
+declare module '@skbkontur/react-ui/Autocomplete' {
+  declare export type AutocompleteProps = {
+    ...$Exact<_InputProps>,
+    renderItem?: (item: string) => React$Node,
+    source?:
+      | $ReadOnlyArray<string>
+      | ((patter: string) => Promise<$ReadOnlyArray<string>>),
+    disablePortal?: boolean,
+    hasShadow?: boolean,
+    menuAlign?: 'left' | 'right',
+    menuMaxHeight?: number | string,
+    menuWidth?: number | string,
+    preventWindowScroll?: boolean,
+    onChange: (
+      event: {
+        target: {
+          value: string,
+          ...
+        },
+        ...
+      },
+      value: string,
+    ) => void,
+    onBlur?: () => void,
+    size?: $PropertyType<_InputProps, 'size'>,
+    value: string,
+    ...
+  };
+
+  declare export type AutocompleteState = {|
+    items: void | null | $ReadOnlyArray<string>,
+    selected: number,
+  |};
+
+  declare export default class Autocomplete extends React$Component<
+    AutocompleteProps,
+    AutocompleteState,
+  > {
+    focus(): void;
+    blur(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Button' {
+  declare export type ButtonSize = _ButtonSize;
+  declare export type ButtonType = _ButtonType;
+  declare export type ButtonArrow = _ButtonArrow;
+  declare export type ButtonUse = _ButtonUse;
+
+  declare export type ButtonProps = {|
+    _noPadding?: boolean,
+    _noRightPadding?: boolean,
+    active?: boolean,
+    align?: string,
+    arrow?: ButtonArrow,
+    autoFocus?: boolean,
+    borderless?: boolean,
+    checked?: boolean,
+    children?: React$Node,
+    corners?: number,
+    disabled?: boolean,
+    disableFocus?: boolean,
+    error?: boolean,
+    focused?: boolean,
+    // eslint-disable-next-line flowtype/no-weak-types
+    icon?: React$Element<any>,
+    loading?: boolean,
+    narrow?: boolean,
+    onBlur?: FocusEventHandler<HTMLButtonElement>,
+    onClick?: MouseEventHandler<HTMLButtonElement>,
+    onFocus?: FocusEventHandler<HTMLButtonElement>,
+    onKeyDown?: KeyboardEventHandler<HTMLButtonElement>,
+    onMouseEnter?: MouseEventHandler<HTMLButtonElement>,
+    onMouseLeave?: MouseEventHandler<HTMLButtonElement>,
+    onMouseOver?: MouseEventHandler<HTMLButtonElement>,
+    size?: ButtonSize,
+    type?: ButtonType,
+    use?: ButtonUse,
+    visuallyFocused?: boolean,
+    warning?: boolean,
+    width?: number | string,
+  |};
+
+  declare export type ButtonState = {|
+    focusedByTab: boolean,
+  |};
+
+  declare export default class Button extends React$Component<
+    ButtonProps,
+    ButtonState,
+  > {
+    static TOP_LEFT: number;
+    static TOP_RIGHT: number;
+    static BOTTOM_RIGHT: number;
+    static BOTTOM_LEFT: number;
+
+    focus(): void;
+    blur(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Calendar' {
+  declare class DayCellViewModel {
+    static create(
+      date: number,
+      month: number,
+      year: number,
+      isWeekend: boolean,
+    ): DayCellViewModel;
+
+    date: number;
+    month: number;
+    year: number;
+    isWeekend: boolean;
+  }
+
+  declare class MonthViewModel {
+    static create: (month: number, year: number) => MonthViewModel;
+
+    +daysCount: number;
+    +offset: number;
+    +month: number;
+    +year: number;
+    +height: number;
+    +days: $ReadOnlyArray<DayCellViewModel>;
+
+    isLastInYear: boolean;
+    isFirstInYear: boolean;
+  }
+
+  declare export type CalendarDateShape = _CalendarDateShape;
+
+  declare export type CalendarProps = {|
+    initialMonth?: number,
+    initialYear?: number,
+    onSelect?: (date: CalendarDateShape) => void,
+    value?: ?CalendarDateShape,
+    maxDate?: CalendarDateShape,
+    minDate?: CalendarDateShape,
+    isHoliday?: (
+      day: CalendarDateShape & {
+        isWeekend: boolean,
+        ...
+      },
+    ) => boolean,
+  |};
+
+  declare export type CalendarState = {|
+    scrollPosition: number,
+    months: $ReadOnlyArray<MonthViewModel>,
+    today: CalendarDateShape,
+    scrollDirection: number,
+    scrollTarget: number,
+  |};
+
+  declare export default class Calendar extends React$Component<
+    CalendarProps,
+    CalendarState,
+  > {
+    scrollToMonth(month: number, year: number): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Center' {
+  declare export type HorizontalAlign = 'left' | 'center' | 'right';
+
+  declare export type CenterProps = {
+    align?: HorizontalAlign,
+    style?: Style,
+    ...
+  };
+
+  declare export type CenterState = {||};
+
+  declare export default class Center extends React$Component<
+    CenterProps,
+    CenterState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Checkbox' {
+  declare export type CheckboxProps = {
+    children?: React$Node,
+    error?: boolean,
+    warning?: boolean,
+    onMouseEnter?: MouseEventHandler<HTMLLabelElement>,
+    onMouseLeave?: MouseEventHandler<HTMLLabelElement>,
+    onMouseOver?: MouseEventHandler<HTMLLabelElement>,
+    onChange?: (
+      event: SyntheticKeyboardEvent<HTMLInputElement>,
+      value: boolean,
+    ) => void,
+    initialIndeterminate?: boolean,
+    ...
+  };
+
+  declare export type CheckboxState = {|
+    focusedByTab: boolean,
+    indeterminate: boolean,
+  |};
+
+  declare export default class Checkbox extends React$Component<
+    CheckboxProps,
+    CheckboxState,
+  > {
+    focus(): void;
+    blur(): void;
+    setIndeterminate: () => void;
+    resetIndeterminate: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/ComboBox' {
+  declare export type ComboBoxItem = _ComboBoxItem;
+
+  declare export type ComboBoxProps<T = ComboBoxItem> = {|
+    align?: 'left' | 'center' | 'right',
+    autocomplete?: boolean,
+    autoFocus?: boolean,
+    borderless?: boolean,
+    disablePortal?: boolean,
+    disabled?: boolean,
+    error?: boolean,
+    getItems?: (query: string) => Promise<$ReadOnlyArray<T>>,
+    itemToValue?: (item: T) => string | number,
+    maxLength?: number,
+    drawArrow?: boolean,
+    menuAlign?: 'left' | 'right',
+    onBlur?: () => void,
+    onChange?: (
+      event: {
+        target: {
+          value: T,
+          ...
+        },
+        ...
+      },
+      item: T,
+    ) => void,
+    onFocus?: () => void,
+    // eslint-disable-next-line flowtype/no-weak-types
+    onInputChange?: (query: string) => any,
+    onUnexpectedInput?: (query: string) => void | null | T,
+    placeholder?: string,
+    renderItem?: (item: T, state?: _MenuItemState) => React$Node,
+    renderNotFound?: () => React$Node,
+    renderTotalCount?: (found: number, total: number) => React$Node,
+    renderValue?: (item: T) => React$Node,
+    totalCount?: number,
+    value?: ?T,
+    valueToString?: (item: T) => string,
+    size?: 'small' | 'medium' | 'large',
+    warning?: boolean,
+    width?: string | number,
+    maxMenuHeight?: number | string,
+  |};
+
+  declare export default class ComboBox<
+    T = ComboBoxItem,
+  > extends React$Component<ComboBoxProps<T>> {
+    focus(): void;
+    search(query?: string): void;
+    open(): void;
+    close(): void;
+    selectInputText(): void;
+    reset(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/ComboBoxOld' {
+  declare export type ComboBoxOldProps<T> = {|
+    autoFocus?: boolean,
+    borderless?: boolean,
+    debounceInterval?: number,
+    disablePortal?: boolean,
+    disabled?: boolean,
+    error?: boolean,
+    info?: mixed | ((value: mixed) => mixed),
+    menuAlign?: 'left' | 'right',
+    openButton?: boolean,
+    placeholder?: string,
+    recover?: boolean | (() => mixed),
+    renderItem?: (value: mixed, info: mixed, state: mixed) => mixed,
+    renderNotFound?: string | (() => mixed),
+    renderTotalCount?: (foundCount: number, totalCount: number) => mixed,
+    renderValue?: (value: mixed, info: mixed) => mixed,
+    valueToString?: (value: mixed, info: mixed) => mixed,
+    source: (query: string) => mixed,
+    value?: mixed,
+    warning?: boolean,
+    width?: number | string,
+    onBlur?: () => mixed,
+    onChange?: (event: mixed, value: mixed) => mixed,
+    onClose?: () => mixed,
+    onFocus?: () => mixed,
+    onInputChange?: (value: string) => mixed,
+    onInputKeyDown?: () => mixed,
+    onMouseEnter?: () => mixed,
+    onMouseLeave?: () => mixed,
+    onMouseOver?: () => mixed,
+    onOpen?: () => mixed,
+  |};
+
+  declare export type ComboBoxOldState = {||};
+
+  declare export default class ComboBoxOld extends React$Component<
+    ComboBoxOldProps<any>,
+    ComboBoxOldState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/CurrencyInput' {
+  declare export type Selection = {|
+    start: number,
+    end: number,
+    direction: SelectionDirection,
+  |};
+
+  declare export type SelectionDirection = 'forward' | 'backward' | 'none';
+
+  declare export type CurrencyInputProps = _CurrencyInputProps;
+
+  declare export type CurrencyInputState = _CurrencyInputState;
+
+  declare export default typeof _CurrencyInput;
+}
+
+declare module '@skbkontur/react-ui/CurrencyLabel' {
+  declare export type CurrencyLabelProps = {|
+    fractionDigits?: number,
+    value: number,
+    currencySymbol?: React$Node | null,
+  |};
+
+  declare var CurrencyLabel: React$ComponentType<CurrencyLabelProps>;
+
+  declare export default typeof CurrencyLabel;
+}
+
+declare module '@skbkontur/react-ui/CustomComboBox' {
+  declare export type Action<T> =
+    | {
+        type: 'ValueChange',
+        value: T,
+        keepFocus: boolean,
+        ...
+      }
+    | {
+        type: 'TextChange',
+        value: string,
+        ...
+      }
+    | {
+        type: 'KeyPress',
+        event: SyntheticKeyboardEvent<HTMLElement>,
+        ...
+      }
+    | {
+        type: 'DidUpdate',
+        prevProps: CustomComboBoxProps<T>,
+        prevState: CustomComboBoxState<T>,
+        ...
+      }
+    | {
+        type: 'Mount',
+        ...
+      }
+    | {
+        type: 'Focus',
+        ...
+      }
+    | {
+        type: 'InputClick',
+        ...
+      }
+    | {
+        type: 'Blur',
+        ...
+      }
+    | {
+        type: 'Reset',
+        ...
+      }
+    | {
+        type: 'Open',
+        ...
+      }
+    | {
+        type: 'Close',
+        ...
+      }
+    | {
+        type: 'Search',
+        query: string,
+        ...
+      };
+
+  declare export type CustomComboBoxProps<T> = {|
+    align?: 'left' | 'center' | 'right',
+    autoFocus?: boolean,
+    borderless?: boolean,
+    disablePortal?: boolean,
+    disabled?: boolean,
+    error?: boolean,
+    maxLength?: number,
+    menuAlign?: 'left' | 'right',
+    openButton?: boolean,
+    onMouseEnter?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    onMouseOver?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    onMouseLeave?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    placeholder?: string,
+    size?: 'small' | 'medium' | 'large',
+    totalCount?: number,
+    value?: ?T,
+    warning?: boolean,
+    width?: string | number,
+    maxMenuHeight?: number | string,
+    renderNotFound?: () => React$Node,
+    renderTotalCount?: (found: number, total: number) => React$Node,
+    renderItem: (item: T, state?: _MenuItemState) => React$Node,
+    renderValue: (value: T) => React$Node,
+    valueToString: (value: T) => string,
+    itemToValue: (item: T) => string | number,
+  |};
+
+  declare export type CustomComboBoxState<T> = {|
+    editing: boolean,
+    loading: boolean,
+    opened: boolean,
+    textValue: string,
+    items: ?$ReadOnlyArray<T>,
+  |};
+
+  declare export type Effect<T> = (
+    dispatch: (x0: Action<T>) => void,
+    getState: () => CustomComboBoxState<T>,
+    getProps: () => CustomComboBoxProps<T>,
+    getInstance: () => CustomComboBox,
+  ) => void;
+
+  declare export type Reducer<T> = (
+    state: CustomComboBoxState<T>,
+    props: CustomComboBoxProps<T>,
+    action: Action<T>,
+  ) =>
+    | CustomComboBoxState<T>
+    | [CustomComboBoxState<T>, $ReadOnlyArray<Effect<T>>];
+
+  declare export type Props<T> = {
+    reducer: Reducer<T>,
+    ...
+  } & CustomComboBoxProps<T>;
+
+  declare var DefaultState: {|
+    editing: boolean,
+    items: null,
+    loading: boolean,
+    opened: boolean,
+    textValue: string,
+  |};
+
+  // eslint-disable-next-line flowtype/no-weak-types
+  declare export default class CustomComboBox extends React$Component<
+    Props<any>,
+    CustomComboBoxState<any>,
+  > {
+    // eslint-disable-next-line flowtype/no-weak-types
+    state: CustomComboBoxState<any>;
+    input: ?_Input;
+    menu: ?_Menu;
+    inputLikeText: ?_InputLikeText;
+
+    focus: () => void;
+    selectInputText: () => void;
+    blur: () => void;
+    search(query?: string): void;
+    open(): void;
+    close(): void;
+    reset(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/DateInput' {
+  declare var DateInputConfig: {|
+    polyfillInput: boolean,
+  |};
+
+  declare var DateParts: {|
+    Date: number,
+    Month: number,
+    Year: number,
+    All: number,
+  |};
+
+  declare export type DateInputState = {|
+    selected: number | null,
+    editingCharIndex: number,
+    date: string | null,
+    month: string | null,
+    year: string | null,
+    minDate: ?_CalendarDateShape,
+    maxDate: ?_CalendarDateShape,
+    notify: boolean,
+  |};
+
+  declare export type DateInputProps = {|
+    value?: string,
+    error?: boolean,
+    warning?: boolean,
+    disabled?: boolean,
+    minDate?: ?string,
+    maxDate?: ?string,
+    width?: string | number,
+    withIcon?: boolean,
+    size?: 'small' | 'large' | 'medium',
+    onBlur?: (x0: SyntheticFocusEvent<HTMLElement>) => void,
+    onFocus?: (x0: SyntheticFocusEvent<HTMLElement>) => void,
+    onChange?: (
+      x0: {|
+        target: {|
+          value: string,
+        |},
+      |},
+      x1: string,
+    ) => void,
+    onKeyDown?: (x0: SyntheticKeyboardEvent<HTMLElement>) => void,
+  |};
+
+  declare export type DateInputSetStateCallBack = (
+    prevState: $ReadOnly<DateInputState>,
+    props?: DateInputProps,
+  ) => DateInputState | null;
+
+  declare export default class DateInput extends React$Component<
+    DateInputProps,
+    DateInputState,
+  > {
+    blur(): void;
+    focus(): void;
+    blink(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/DatePicker' {
+  declare export type DatePickerProps<T> = {|
+    autoFocus?: boolean,
+    disabled?: boolean,
+    enableTodayLink?: boolean,
+    error?: boolean,
+    minDate?: T,
+    maxDate?: T,
+    menuAlign?: 'left' | 'right',
+    size?: 'small' | 'medium' | 'large',
+    value: T | null,
+    warning?: boolean,
+    width?: number | string,
+    onBlur?: () => void,
+    onChange: (
+      e: {|
+        target: {|
+          value: T,
+        |},
+      |},
+      v: T,
+    ) => void,
+    onFocus?: () => void,
+    /* eslint-disable flowtype/no-weak-types */
+    onKeyDown?: (e: SyntheticKeyboardEvent<any>) => void,
+    onMouseEnter?: (e: SyntheticMouseEvent<any>) => void,
+    onMouseLeave?: (e: SyntheticMouseEvent<any>) => void,
+    onMouseOver?: (e: SyntheticMouseEvent<any>) => void,
+    /* eslint-enable flowtype/no-weak-types */
+    isHoliday?: (day: T, isWeekend: boolean) => boolean,
+  |};
+
+  declare export type DatePickerState = {|
+    opened: boolean,
+  |};
+
+  declare export type DatePickerValue = string;
+
+  declare export default class DatePicker extends React$Component<
+    DatePickerProps<DatePickerValue>,
+    DatePickerState,
+  > {
+    static validate: (value: string | null | void) => boolean;
+
+    blur(): void;
+    focus(): void;
+    close(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/DatePickerOld' {
+  declare export type DatePickerOldProps = {|
+    autoFocus?: boolean,
+    className?: string,
+    disabled?: boolean,
+    error?: boolean,
+    maxYear?: number,
+    minYear?: number,
+    menuAlign?: 'left' | 'right',
+    onBlur?: () => void,
+    onChange?: (
+      e: {|
+        target: {|
+          value: Date,
+        |},
+      |},
+      value: Date,
+    ) => void,
+    onFocus?: () => void,
+    onInput?: InputEventHandler<HTMLElement>,
+    onKeyDown?: KeyboardEventHandler<HTMLElement>,
+    onKeyPress?: KeyboardEventHandler<HTMLElement>,
+    onKeyUp?: KeyboardEventHandler<HTMLElement>,
+    onMouseEnter?: MouseEventHandler<HTMLElement>,
+    onMouseLeave?: MouseEventHandler<HTMLElement>,
+    onMouseOver?: MouseEventHandler<HTMLElement>,
+    onUnexpectedInput?: (value: string) => void,
+    placeholder?: string,
+    size?: 'small' | 'medium' | 'large',
+    value?: Date | string,
+    warning?: boolean,
+    width?: number | string,
+    withMask?: boolean,
+  |};
+
+  declare export type DatePickerOldState = {||};
+
+  declare export default class DatePicker extends React$Component<
+    DatePickerOldProps,
+    DatePickerOldState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/DateSelect' {
+  declare var MONTHS: $ReadOnlyArray<string>;
+
+  declare export type DateSelectProps = {|
+    disabled?: boolean | null,
+    onChange: (value: number) => void,
+    type?: 'month' | 'year',
+    value: number,
+    width?: number | string,
+    minValue?: number,
+    maxValue?: number,
+  |};
+
+  declare export type DateSelectState = {|
+    botCapped: boolean,
+    current: ?number,
+    height: number,
+    opened: boolean,
+    pos: number,
+    top: number,
+    topCapped: boolean,
+    nodeTop: number,
+  |};
+
+  declare export default class DateSelect extends React$Component<
+    DateSelectProps,
+    DateSelectState,
+  > {
+    open: () => void;
+    close: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Dropdown' {
+  declare export type DropdownProps = {|
+    caption: React$Node,
+    // eslint-disable-next-line flowtype/no-weak-types
+    icon?: React$Element<any>,
+    width?: number | string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    _renderButton?: (params: any) => React$Node,
+    disablePortal?: boolean,
+    disabled?: boolean,
+    error?: boolean,
+    warning?: boolean,
+    maxMenuHeight?: number,
+    menuAlign?: 'left' | 'right',
+    menuWidth?: number | string,
+    size?: _ButtonSize,
+    use?: _ButtonUse,
+    onClose?: () => void,
+    onOpen?: () => void,
+    children?: React$Node,
+    onMouseEnter?: MouseEventHandler<HTMLElement>,
+    onMouseLeave?: MouseEventHandler<HTMLElement>,
+    onMouseOver?: MouseEventHandler<HTMLElement>,
+  |};
+
+  declare export default class Dropdown extends React$Component<DropdownProps> {
+    static Header: typeof _MenuHeader;
+    static MenuItem: typeof _MenuItem;
+    static Separator: typeof _MenuSeparator;
+
+    open(): void;
+    close(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/DropdownContainer/DropdownContainer' {
+  declare export type DropdownMenuProps = {|
+    menuMaxHeight?: string | number,
+    menuWidth?: string | number,
+    caption: $PropertyType<_PopupMenuProps, 'caption'>,
+    onOpen?: () => void,
+    onClose?: () => void,
+    disableAnimations?: boolean,
+    children?: React$Node,
+    header?: React$Node,
+    footer?: React$Node,
+    positions?: $ReadOnlyArray<_PopupPosition>,
+  |};
+
+  declare export default class DropdownMenu extends React$Component<DropdownMenuProps> {}
+}
+
+declare module '@skbkontur/react-ui/DropdownMenu' {
+  declare export type DropdownMenuProps = {|
+    menuMaxHeight?: string | number,
+    menuWidth?: string | number,
+    caption: $PropertyType<_PopupMenuProps, 'caption'>,
+    onOpen?: () => void,
+    onClose?: () => void,
+    disableAnimations?: boolean,
+    children?: React$Node,
+    header?: React$Node,
+    footer?: React$Node,
+    positions?: $ReadOnlyArray<_PopupPosition>,
+  |};
+
+  declare export default class DropdownMenu extends React$Component<DropdownMenuProps> {}
+}
+
+declare module '@skbkontur/react-ui/Fias' {
+  declare class FiasData {
+    static isAddressObject: (data: FiasObject) => boolean;
+    static isStead: (data: FiasObject) => boolean;
+    static isHouse: (data: FiasObject) => boolean;
+
+    data: FiasObject;
+  }
+
+  declare class AddressElement {
+    type: Fields;
+    name: string;
+    data?: ?FiasData;
+
+    +isFederalCity: boolean;
+    +verifiableData: $Shape<FiasData>;
+
+    getText(withoutType?: boolean): string;
+    isTypeMatchField: (field: Fields) => boolean;
+  }
+
+  declare export type FiasId = string;
+
+  declare export type FiasEntity = {|
+    id: string,
+    fiasId: FiasId,
+    parentFiasId?: FiasId,
+  |};
+
+  declare export type AddressObject = {|
+    ...$Exact<FiasEntity>,
+    name: string,
+    abbreviation: string,
+    code: string,
+  |};
+
+  declare export type Stead = {|
+    ...$Exact<FiasEntity>,
+    number: string,
+    liveStatus: LiveStatuses,
+  |};
+
+  declare export type House = {|
+    ...$Exact<FiasEntity>,
+    estateStatus: EstateStatuses,
+    structureStatus: StructureStatuses,
+    number?: string,
+    structureNumber?: string,
+    buildingNumber?: string,
+  |};
+
+  declare export type Room = {|
+    ...$Exact<FiasEntity>,
+    flatNumber: string,
+    flatType: number,
+    liveStatus: LiveStatuses,
+  |};
+
+  declare export type EstateStatuses = 'Hold' | 'House' | 'HouseHold' | 'None';
+
+  declare export type StructureStatuses =
+    | 'Structure'
+    | 'Construction'
+    | 'Liter'
+    | 'None';
+
+  declare export type LiveStatuses = 'active' | 'inactive';
+
+  declare export type FiasObject = AddressObject | Stead | House | Room;
+
+  declare export type Fields =
+    | 'region'
+    | 'district'
+    | 'city'
+    | 'intracityarea'
+    | 'settlement'
+    | 'planningstructure'
+    | 'street'
+    | 'stead'
+    | 'house'
+    | 'room';
+
+  declare export type ExtraFields = 'postalcode';
+
+  declare export type AddressFields = {
+    [key: Fields]: ?AddressElement,
+    ...,
+  };
+
+  declare export type FiasValue = {|
+    address?: AddressValue,
+    addressString?: string,
+    addressErrors?: AddressErrors,
+    fiasId?: FiasId,
+  |};
+
+  declare export type AddressValue = {|
+    [key: Fields]: void | {|
+      name: string,
+      data?: FiasObject,
+    |},
+  |};
+
+  declare export type AddressResponse = {|
+    [key: Fields]: void | FiasObject,
+  |};
+
+  declare export type SearchResponse = $ReadOnlyArray<AddressResponse>;
+
+  declare export type VerifyResponse = $ReadOnlyArray<{|
+    address: AddressResponse,
+    isValid: boolean,
+    invalidLevel?: string,
+  |}>;
+
+  declare export type AddressErrors = {
+    [key: Fields]: void | string,
+    ...,
+  };
+
+  declare export type FormValidation = 'Error' | 'Warning' | 'None';
+
+  declare export type SearchOptions = {|
+    fiasId?: FiasId,
+    searchText?: string,
+    field?: Fields,
+    parentFiasId?: FiasId,
+    limit?: number,
+    fullAddress?: boolean,
+    directParent?: boolean,
+  |};
+
+  declare export type APIProvider = {|
+    search: (options: SearchOptions) => Promise<APIResult<SearchResponse>>,
+    verify: (address: AddressValue) => Promise<APIResult<VerifyResponse>>,
+  |};
+
+  declare export type APIResult<Data> = {|
+    success: boolean,
+    data?: Data,
+    error?: Error,
+  |};
+
+  declare export type FetchFn = (
+    uri: string,
+    options: {|
+      method?: 'GET' | 'POST',
+      body?: string,
+    |},
+  ) => Promise<FetchResponse>;
+
+  declare export type FetchResponse = {|
+    ok: boolean,
+    status: number,
+    statusText: string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    json: () => Promise<any>,
+  |};
+
+  declare export type FieldsSettings = {|
+    [field: Fields | ExtraFields]: {|
+      visible?: boolean,
+    |} | void,
+  |};
+
+  declare export type FiasCountry = {|
+    shortName: string,
+    fullName: string,
+    code: string,
+  |};
+
+  declare class Address {
+    static ALL_FIELDS: $ReadOnlyArray<Fields>;
+    static VERIFIABLE_FIELDS: $ReadOnlyArray<Fields>;
+    static FULL_ADDRESS_SEARCH_FIELDS: $ReadOnlyArray<Fields>;
+    static ALL_PARENTS_SEARCH_FIELDS: $ReadOnlyArray<Fields>;
+    static createFromResponse: (response: AddressResponse) => Address;
+    static createFromAddressValue: (addressValue: AddressValue) => Address;
+    static verify: (
+      address: Address,
+      response: $ReadOnlyArray<{|
+        address: AddressResponse,
+        isValid: boolean,
+        invalidLevel?: string | void,
+      |}>,
+      notVerifiedMessage: string,
+    ) => Address;
+    static getParentFields: (field: Fields) => $ReadOnlyArray<Fields>;
+    static filterVisibleFields: (
+      fields: {| [key: Fields]: any |},
+      fieldsSettings: FieldsSettings,
+    ) => {| [key: Fields]: any |};
+    static getChildFields: (field: Fields) => $ReadOnlyArray<Fields>;
+    static removeFiasData: (
+      address: Address,
+      fields: $ReadOnlyArray<Fields>,
+    ) => Address;
+    static getAddress: (
+      api: APIProvider,
+      value?: FiasValue,
+      fieldsSettings?: FieldsSettings,
+    ) => Promise<Address>;
+
+    +isEmpty: boolean;
+    +hasErrors: boolean;
+
+    fields: AddressFields;
+    errors: AddressErrors;
+
+    hasError(field: Fields): boolean;
+    getError(field: Fields): string | void;
+    getAddressErrors: () => {|
+      region?: string | void,
+      district?: string | void,
+      city?: string | void,
+      intracityarea?: string | void,
+      settlement?: string | void,
+      planningstructure?: string | void,
+      street?: string | void,
+      stead?: string | void,
+      house?: string | void,
+      room?: string | void,
+    |};
+    getText: (
+      minField?: Fields | void,
+      skipTypes?: boolean,
+      connector?: string,
+    ) => string;
+    isAllowedToFill: (field: ?Fields) => boolean;
+    isAllowedToSearchFullAddress: (field?: Fields | void) => boolean;
+    isAllowedToSearchThroughChildrenOfDirectParent: (
+      field?: Fields | void,
+    ) => boolean;
+    hasOnlyIndirectParent: (field: ?Fields) => boolean;
+    getClosestParentFiasId: (field?: Fields | void) => string | void;
+    getFiasId: () => string;
+    getAddressValue: () => AddressValue;
+    getValue: (withPostalCode?: boolean) => FiasValue;
+    convertForVerification: () => { ... };
+  }
+
+  declare export type FiasLocale = _FiasLocale;
+
+  declare export type FiasProps = {|
+    value?: FiasValue,
+    error?: boolean,
+    warning?: boolean,
+    feedback?: string,
+    showAddressText?: boolean,
+    label?: string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    icon?: React$Element<any>,
+    readonly?: boolean,
+    baseUrl?: string,
+    api?: APIProvider,
+    onInit?: (value: FiasValue) => void,
+    onChange?: (value: FiasValue) => void,
+    onClose?: () => void,
+    search?: boolean,
+    limit?: number,
+    locale?: FiasLocale,
+    formValidation?: FormValidation,
+    allowNotVerified?: boolean,
+    version?: string,
+  |};
+
+  declare export type FiasState = {|
+    opened: boolean,
+    address: Address,
+    locale: FiasLocale,
+  |};
+
+  declare export default class Fias extends React$Component<
+    FiasProps,
+    FiasState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/FxInput' {
+  declare export type FxInputProps = {
+    auto?: boolean,
+    type?: 'currency' | $PropertyType<_InputProps, 'type'>,
+    onRestore?: () => void,
+    onChange:
+      | $PropertyType<_CurrencyInputProps, 'onChange'>
+      | $PropertyType<_InputProps, 'onChange'>,
+    value?: string | number,
+    refInput?: (element: _CurrencyInput | _Input | null) => void,
+    ...
+  };
+
+  declare export type FxInputDefaultProps = {|
+    width: $PropertyType<FxInputProps, 'width'>,
+    type: $PropertyType<FxInputProps, 'type'>,
+  |};
+
+  declare export default class FxInput extends React$Component<FxInputProps> {
+    focus: () => void;
+    blur: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Gapped' {
+  declare export type GappedProps = {|
+    gap?: number,
+    verticalAlign?: string | number,
+    vertical?: boolean,
+    children: React$Node,
+  |};
+
+  declare export default class Gapped extends React$Component<GappedProps> {}
+}
+
+declare module '@skbkontur/react-ui/Group' {
+  declare export type GroupProps = {|
+    width?: string | number,
+  |};
+
+  declare export type GroupChildProps = {|
+    mainInGroup?: boolean,
+    width?: string | number,
+    corners?: number,
+  |};
+
+  declare export default class Group extends React$Component<GroupProps> {}
+}
+
+declare module '@skbkontur/react-ui/HideBodyVerticalScroll' {
+  declare export default class HideBodyVerticalScroll extends React$Component<{||}> {
+    static hash: string;
+  }
+}
+
+declare module '@skbkontur/react-ui/Hint' {
+  declare export type HintProps = {|
+    children?: React$Node,
+    manual?: boolean,
+    maxWidth?: string | number,
+    opened?: boolean,
+    pos?:
+      | 'top'
+      | 'right'
+      | 'bottom'
+      | 'left'
+      | 'top left'
+      | 'top center'
+      | 'top right'
+      | 'bottom left'
+      | 'bottom center'
+      | 'bottom right'
+      | 'left top'
+      | 'left middle'
+      | 'left bottom'
+      | 'right top'
+      | 'right middle'
+      | 'right bottom',
+    text: React$Node,
+    disableAnimations?: boolean,
+    useWrapper?: boolean,
+    onMouseEnter?: (
+      event: SyntheticMouseEvent<HTMLElement> | MouseEvent,
+    ) => void,
+    onMouseLeave?: (
+      event: SyntheticMouseEvent<HTMLElement> | MouseEvent,
+    ) => void,
+  |};
+
+  declare export type HintState = {|
+    opened: boolean,
+  |};
+
+  declare export default class Hint extends React$Component<
+    HintProps,
+    HintState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Icon/20px' {
+  declare export type MAP = _MAP;
+
+  declare export type IconProps = _IconProps;
+
+  declare export default class Icon extends React$Component<IconProps> {
+    static getAllNames(): $ReadOnlyArray<string>;
+  }
+}
+
+declare module '@skbkontur/react-ui/IgnoreLayerClick' {
+  declare export type IgnoreLayerClickProps = {|
+    children: React$Node,
+    active: boolean,
+  |};
+
+  declare export default class IgnoreLayerClick extends React$Component<IgnoreLayerClickProps> {}
+}
+
+declare module '@skbkontur/react-ui/Input' {
+  declare export type InputSize = 'small' | 'medium' | 'large';
+  declare export type InputAlign = 'left' | 'center' | 'right';
+  declare export type InputType = 'password' | 'text';
+  declare export type IconType = React$Node | (() => React$Node);
+
+  declare export type InputProps = _InputProps;
+
+  declare export type InputVisibilityState = _InputVisibilityState;
+
+  declare export type InputState = _InputState;
+
+  declare export default typeof _Input;
+}
+
+declare module '@skbkontur/react-ui/Kebab' {
+  declare export type KebabProps = {|
+    disabled?: boolean,
+    onClose: () => void,
+    onOpen: () => void,
+    size?: 'small' | 'medium' | 'large',
+    positions?: $ReadOnlyArray<_PopupPosition>,
+    menuMaxHeight?: number | string,
+    disableAnimations?: boolean,
+    children?: React$Node,
+  |};
+
+  declare export type KebabState = {|
+    anchor: ?HTMLElement,
+    focusedByTab: boolean,
+    opened: boolean,
+  |};
+
+  declare export default class Kebab extends React$Component<
+    KebabProps,
+    KebabState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Kladr' {
+  declare export type PlaceDescription = {|
+    code: string,
+    fiasGuid: string,
+    name: string,
+    abbreviation: string,
+    isError: boolean,
+  |};
+
+  declare export type Address = {
+    region: PlaceDescription,
+    district: PlaceDescription,
+    city: PlaceDescription,
+    settlement: PlaceDescription,
+    street: PlaceDescription,
+    index: string,
+    okato: string,
+    house: string,
+    building: string,
+    room: string,
+    ...
+  };
+
+  declare export type KladrValue = {|
+    address: Address,
+  |};
+
+  declare export type KladrProps = {|
+    error?: string,
+    title: string,
+    value: any,
+    warning?: string,
+    onChange?: (event: any, value: KladrValue) => void,
+  |};
+
+  declare export type KladrState = {|
+    opened: boolean,
+  |};
+
+  declare export default class Kladr extends React$Component<
+    KladrProps,
+    KladrState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Link' {
+  declare export type LinkProps = {
+    disabled?: boolean,
+    href?: string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    icon?: React$Element<any>,
+    use?: 'default' | 'success' | 'danger' | 'grayed',
+    _button?: boolean,
+    _buttonOpened?: boolean,
+    tabIndex?: number,
+    onClick?: MouseEventHandler<HTMLAnchorElement>,
+    ...
+  };
+
+  declare export type LinkState = {|
+    focusedByTab: boolean,
+  |};
+
+  declare export default class Link extends React$Component<
+    LinkProps,
+    LinkState,
+  > {
+    // eslint-disable-next-line flowtype/no-weak-types
+    static __ADAPTER__: any;
+  }
+}
+
+declare module '@skbkontur/react-ui/Loader' {
+  declare export type LoaderProps = {|
+    children?: React$Node,
+    active: boolean,
+    caption?: $PropertyType<_SpinnerProps, 'caption'>,
+    className?: string,
+    type?: 'mini' | 'normal' | 'big',
+  |};
+
+  declare export type LoaderState = {|
+    isStickySpinner: boolean,
+    spinnerStyle?: Style,
+  |};
+
+  declare export default class Loader extends React$Component<
+    LoaderProps,
+    LoaderState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/LocaleProvider' {
+  declare export type LocaleControls = {|
+    Fias?: $Shape<_FiasLocale>,
+    TopBar?: $Shape<_TopBarLocale>,
+    Select?: $Shape<_SelectLocale>,
+    Paging?: $Shape<_PagingLocale>,
+    Spinner?: $Shape<_SpinnerLocale>,
+    ComboBox?: $Shape<_ComboBoxLocale>,
+    Logotype?: $Shape<_LogotypeLocale>,
+    TokenInput?: $Shape<_TokenInputLocale>,
+    DatePicker?: $Shape<_DatePickerLocale>,
+  |};
+
+  declare export type LocaleProviderProps = {|
+    locale?: LocaleControls,
+    langCode?: 'ru_RU' | 'en_GB',
+    children?: React$Node,
+  |};
+
+  declare var LocaleConsumer: React$ComponentType<LocaleProviderProps>;
+
+  declare export default class LocaleProvider extends React$Component<LocaleProviderProps> {}
+}
+
+declare module '@skbkontur/react-ui/Logotype' {
+  declare export type LogotypeLocale = _LogotypeLocale;
+
+  declare export type LogotypeProps = {|
+    color?: string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    component?: React$ComponentType<any> | string,
+    href?: string,
+    suffix?: string,
+    textColor?: string,
+    withWidget?: boolean,
+    locale?: LogotypeLocale,
+  |};
+
+  declare export default class Logotype extends React$Component<LogotypeProps> {}
+}
+
+declare module '@skbkontur/react-ui/Menu/Menu' {
+  declare export type MenuProps = _MenuProps;
+
+  declare export type MenuState = _MenuState;
+
+  declare export default typeof _Menu;
+}
+
+declare module '@skbkontur/react-ui/MenuHeader' {
+  declare export type MenuHeaderProps = _MenuHeaderProps;
+
+  declare export default typeof _MenuHeader;
+}
+
+declare module '@skbkontur/react-ui/MenuItem' {
+  declare export type MenuItemState = _MenuItemState;
+
+  declare export type MenuItemElement = HTMLAnchorElement | HTMLSpanElement;
+
+  declare export type MenuItemProps = _MenuItemProps;
+
+  declare export default typeof _MenuItem;
+}
+
+declare module '@skbkontur/react-ui/MenuSeparator' {
+  declare export type MenuSeparatorProps = {||};
+
+  declare export default typeof _MenuSeparator;
+}
+
+declare module '@skbkontur/react-ui/Modal' {
+  declare export type HeaderProps = {|
+    close?: boolean,
+    sticky?: boolean,
+    children?: React$Node,
+  |};
+
+  declare function isHeader(child: React$Node): boolean;
+
+  declare class Header extends React$Component<HeaderProps> {}
+
+  declare export type BodyProps = {|
+    children?: React$Node,
+  |};
+
+  declare class Body extends React$Component<BodyProps> {}
+
+  declare export type FooterProps = {|
+    panel?: boolean,
+    sticky?: boolean,
+    children?: React$Node,
+  |};
+
+  declare function isFooter(child: React$Node): boolean;
+
+  declare class Footer extends React$Component<FooterProps> {}
+
+  declare export type ModalProps = {|
+    children?: React$Node,
+    disableClose?: boolean,
+    alignTop?: boolean,
+    ignoreBackgroundClick?: boolean,
+    noClose?: boolean,
+    width?: number | string,
+    onClose?: () => void,
+  |};
+
+  declare export type ModalState = {|
+    stackPosition: number,
+    horizontalScroll: boolean,
+    clickTrapHeight?: string | number,
+  |};
+
+  declare export default class Modal extends React$Component<
+    ModalProps,
+    ModalState,
+  > {
+    static Header: typeof Header;
+    static Body: typeof Body;
+    static Footer: typeof Footer;
+  }
+}
+
+declare module '@skbkontur/react-ui/ModalStack' {
+  declare export default class ModalStack {
+    // eslint-disable-next-line flowtype/no-weak-types
+    static add(
+      component: React$Component<any>,
+      onChange: (stack: $ReadOnlyArray<React$Component<any>>) => void,
+    ): any;
+    // eslint-disable-next-line flowtype/no-weak-types
+    static remove(component: React$Component<any>): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Paging' {
+  declare export type ItemComponentProps = {|
+    active: boolean,
+    children?: React$Node,
+    className: string,
+    onClick: () => void,
+    pageNumber: number | 'forward',
+    tabIndex: number,
+  |};
+
+  declare export type PagingProps = {|
+    activePage: number,
+    component?: React$ComponentType<ItemComponentProps>,
+    onPageChange: (pageNumber: number) => void,
+    pagesCount: number,
+    disabled?: boolean,
+    strings?: {|
+      forward: string,
+    |},
+    withoutNavigationHint?: boolean,
+    caption?: string,
+    useGlobalListener?: boolean,
+  |};
+
+  declare export type PagingState = {|
+    focusedByTab: boolean,
+    focusedItem: ?ItemType,
+    keyboardControl: boolean,
+  |};
+
+  declare export type ItemType = number | '.' | 'forward';
+
+  declare export default class Paging extends React$Component<
+    PagingProps,
+    PagingState,
+  > {
+    static isForward(pageNumber: number | 'forward'): boolean;
+  }
+}
+
+declare module '@skbkontur/react-ui/PasswordInput' {
+  declare export type PasswordInputProps = {|
+    ...$Exact<_InputProps>,
+    detectCapsLock?: boolean,
+  |};
+
+  declare export type PasswordInputState = {|
+    visible: boolean,
+    capsLockEnabled?: boolean | null,
+  |};
+
+  declare export type InputProps = {|
+    ...$Exact<PasswordInputProps>,
+    onKeyDown: (event: SyntheticKeyboardEvent<HTMLInputElement>) => void,
+    onKeyPress: (event: SyntheticKeyboardEvent<HTMLInputElement>) => void,
+    rightIcon: () => React$Node,
+  |};
+
+  declare export default class PasswordInput extends React$Component<
+    PasswordInputProps,
+    PasswordInputState,
+  > {
+    focus: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/PerformanceMetrics/PerformanceMetrics' {
+  declare export type PerformanceMetricsProps = {|
+    componentsA: React$Element<any>,
+    componentsB: React$Element<any>,
+  |};
+
+  declare export function PerformanceMetrics(
+    props: PerformanceMetricsProps,
+  ): React$Node;
+}
+
+declare module '@skbkontur/react-ui/Popup' {
+  declare export type PopupPosition = _PopupPosition;
+
+  declare var PopupPositions: $ReadOnlyArray<PopupPosition>;
+
+  declare export type PopupHandlerProps = {|
+    onMouseEnter?: (
+      event: SyntheticMouseEvent<HTMLElement> | MouseEvent,
+    ) => void,
+    onMouseLeave?: (
+      event: SyntheticMouseEvent<HTMLElement> | MouseEvent,
+    ) => void,
+    onClick?: (event: SyntheticMouseEvent<HTMLElement> | MouseEvent) => void,
+    onFocus?: (event: SyntheticFocusEvent<HTMLElement> | FocusEvent) => void,
+    onBlur?: (event: SyntheticFocusEvent<HTMLElement> | FocusEvent) => void,
+    onOpen?: () => void,
+  |};
+
+  declare export type PopupProps = {|
+    ...$Exact<PopupHandlerProps>,
+    anchorElement: React$Node | HTMLElement,
+    backgroundColor?: string,
+    borderColor?: string,
+    children: React$Node | (() => React$Node),
+    hasPin: boolean,
+    hasShadow: boolean,
+    disableAnimations: boolean,
+    margin: number,
+    maxWidth: number | string,
+    opened: boolean,
+    pinOffset: number,
+    pinSize: number,
+    popupOffset: number,
+    positions: $ReadOnlyArray<string>,
+    onCloseRequest?: () => void,
+  |};
+
+  declare export type PopupLocation = {|
+    coordinates: {|
+      left: number,
+      top: number,
+    |},
+    position: string,
+  |};
+
+  declare export type PopupState = {|
+    location: ?PopupLocation,
+  |};
+
+  declare export default class Popup extends React$Component<
+    PopupProps,
+    PopupState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Radio' {
+  declare export type SyntheticRadioEvent<T> = _SyntheticRadioEvent<T>;
+
+  declare export type RadioProps<T> = {
+    error?: boolean,
+    warning?: boolean,
+    focused?: boolean,
+    pressed?: boolean,
+    hovered?: boolean,
+    active?: boolean,
+    onChange?: (event: SyntheticRadioEvent<T>, value: T) => void,
+    onMouseEnter?: (event: SyntheticRadioEvent<T>) => void,
+    onMouseLeave?: (event: SyntheticRadioEvent<T>) => void,
+    onMouseOver?: (event: SyntheticRadioEvent<T>) => void,
+    value: T,
+    ...
+  };
+
+  declare export default class Radio<T> extends React$Component<RadioProps<T>> {
+    focus(): void;
+    blur(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/RadioGroup' {
+  declare export type PreventProps = {|
+    children?: React$Node,
+  |};
+
+  declare class Prevent extends React$Component<PreventProps> {}
+
+  declare export type ItemType<T> = T | [T, React$Node];
+
+  declare export type RadioGroupProps<T> = {|
+    defaultValue?: T,
+    value?: T,
+    items?: $ReadOnlyArray<ItemType<T>>,
+    name?: string,
+    disabled?: boolean,
+    warning?: boolean,
+    error?: boolean,
+    inline?: boolean,
+    children?: React$Node,
+    width?: string | number,
+    renderItem?: (itemValue: T, data: React$Node) => React$Node,
+    onChange?: (event: _SyntheticRadioEvent<T>, value: T) => any,
+    onMouseLeave?: () => any,
+    onMouseOver?: () => any,
+    onMouseEnter?: () => any,
+  |};
+
+  declare export type RadioGroupState<T> = {|
+    activeItem?: T,
+  |};
+
+  declare function renderItem(_value: any, data: React$Node): React$Node;
+
+  declare export default class RadioGroup<T> extends React$Component<
+    RadioGroupProps<T>,
+    RadioGroupState<T>,
+  > {
+    static Prevent: typeof Prevent;
+
+    focus(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/RenderContainer' {
+  declare export type RenderContainerProps = {|
+    anchor?: React$Node,
+  |};
+
+  declare export default class RenderContainer extends React$Component<RenderContainerProps> {
+    static lastId: number;
+  }
+}
+
+declare module '@skbkontur/react-ui/RenderLayer' {
+  declare export type RenderLayerProps = {|
+    children: React$Node,
+    onClickOutside?: (e: Event) => void,
+    onFocusOutside?: (e: Event) => void,
+    active?: boolean,
+  |};
+
+  declare export default class RenderLayer extends React$Component<RenderLayerProps> {}
+}
+
+declare module '@skbkontur/react-ui/ScrollContainer' {
+  declare export type ScrollContainerProps = {|
+    invert?: boolean,
+    maxHeight?: string | number,
+    preventWindowScroll?: boolean,
+  |};
+
+  declare export type ScrollContainerState = {|
+    scrollActive: boolean,
+    hover: boolean,
+    scrolling: boolean,
+    scrollSize: number,
+    scrollPos: number,
+  |};
+
+  declare export default class ScrollContainer extends React$Component<
+    ScrollContainerProps,
+    ScrollContainerState,
+  > {
+    scrollTo(element: HTMLElement): void;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Select' {
+  declare class Item extends React$Component<{|
+    children?: React$Node,
+  |}> {}
+
+  declare export type ButtonParams = {|
+    disabled?: boolean,
+    label: React$Node,
+    onClick: () => void,
+    onKeyDown: (event: SyntheticKeyboardEvent<HTMLElement>) => void,
+    opened: boolean,
+    isPlaceholder: boolean,
+  |};
+
+  declare export type SelectProps<TValue, TItem> = {|
+    // eslint-disable-next-line flowtype/no-weak-types
+    _icon?: React$Element<any>,
+    _renderButton?: (params: ButtonParams) => React$Node,
+    defaultValue?: TValue,
+    // eslint-disable-next-line flowtype/no-weak-types
+    diadocLinkIcon?: React$Element<any>,
+    disablePortal?: boolean,
+    disabled?: boolean,
+    error?: boolean,
+    filterItem?: (value: TValue, item: TItem, pattern: string) => boolean,
+    // eslint-disable-next-line flowtype/no-weak-types
+    items?: $ReadOnlyArray<
+      [TValue, TItem] | TItem | React$Element<any> | (() => React$Element<any>),
+    >,
+    maxMenuHeight?: number,
+    maxWidth?: string | number,
+    menuAlign?: 'left' | 'right',
+    menuWidth?: string | number,
+    onChange?: (
+      e: {|
+        target: {|
+          value: TValue,
+        |},
+      |},
+      value: TValue,
+    ) => void,
+    onClose?: () => void,
+    onMouseEnter?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    onMouseLeave?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    onMouseOver?: (e: SyntheticMouseEvent<HTMLElement>) => void,
+    onOpen?: () => void,
+    placeholder?: React$Node,
+    renderItem?: (value: TValue, item?: TItem) => React$Node,
+    renderValue?: (value: TValue, item?: TItem) => React$Node,
+    areValuesEqual?: (value1: TValue, value2: TValue) => boolean,
+    search?: boolean,
+    value?: TValue,
+    width?: number | string,
+    warning?: boolean,
+    use?: _ButtonUse,
+    size?: _ButtonSize,
+    onFocus?: FocusEventHandler<HTMLElement>,
+    onBlur?: FocusEventHandler<HTMLElement>,
+  |};
+
+  declare export type SelectState<TValue> = {|
+    opened: boolean,
+    searchPattern?: string,
+    value: ?TValue,
+  |};
+
+  declare function renderValue(value: any, item: any): any;
+  declare function renderItem(value: any, item: any): any;
+  declare function areValuesEqual(value1: any, value2: any): boolean;
+  declare function filterItem(value: any, item: any, pattern: string): boolean;
+
+  declare export default class Select<
+    TValue = { ... },
+    TItem = { ... },
+  > extends React$Component<SelectProps<TValue, TItem>, SelectState<TValue>> {
+    static Item: typeof Item;
+    static SEP: () => React$Node;
+    static static: (
+      element:
+        | string
+        | number
+        | boolean
+        | { ... }
+        | React$Element<any>
+        | React$Node
+        | React$Portal
+        | (() => React$Node)
+        | null
+        | void,
+    ) => { ... } | null | void;
+    open: () => void;
+    close: () => void;
+    focus(): void;
+  }
+}
+
+declare module '@skbkontur/react-ui/SidePage' {
+  declare export type Props = {|
+    children?: React$Node,
+  |};
+
+  declare class SidePageContainer extends React$Component<Props> {}
+
+  declare export type SidePageHeaderProps = {|
+    children?: React$Node | ((fixed: boolean) => React$Node),
+  |};
+
+  declare class SidePageHeader extends React$Component<SidePageHeaderProps> {
+    renderClose(): React$Node;
+  }
+
+  declare export type SidePageFooterProps = {|
+    children?: React$Node | ((fixed: boolean) => React$Node),
+    context?: SidePageContextType,
+    panel?: boolean,
+  |};
+
+  declare class SidePageFooter extends React$Component<SidePageFooterProps> {
+    update: () => void;
+  }
+
+  declare var SidePageFooterWithContext: (
+    props: SidePageFooterProps,
+  ) => React$Node;
+
+  declare export type SidePageContextType = {|
+    requestClose: () => void,
+    width: number | string,
+    updateLayout: () => void,
+    footerRef: (ref: SidePageFooter | null) => void,
+  |};
+
+  declare var SidePageContext: React$Context<SidePageContextType>;
+
+  declare var withContext: <P: { ... }>(
+    BaseComponent: React$ComponentType<
+      P & {|
+        context?: SidePageContextType | void,
+      |},
+    >,
+  ) => (props: P) => React$Node;
+
+  declare export type SidePageBodyProps = {|
+    children?: React$Node,
+    context?: SidePageContextType,
+  |};
+
+  declare class SidePageBody extends React$Component<SidePageBodyProps> {}
+
+  declare var SidePageBodyWithContext: (props: SidePageBodyProps) => React$Node;
+
+  declare export type SidePageProps = {|
+    blockBackground?: boolean,
+    disableClose?: boolean,
+    ignoreBackgroundClick?: boolean,
+    width?: number,
+    onClose?: () => void,
+    fromLeft?: boolean,
+    disableAnimations?: boolean,
+    children?: React$Node,
+  |};
+
+  declare export type SidePageState = {|
+    stackPosition?: number,
+    hasMargin?: boolean,
+    hasShadow?: boolean,
+    hasBackground?: boolean,
+  |};
+
+  declare export default class SidePage extends React$Component<
+    SidePageProps,
+    SidePageState,
+  > {
+    static Header: typeof SidePageHeader;
+    static Body: typeof SidePageBody;
+    static Footer: typeof SidePageFooter;
+    static Container: typeof SidePageContainer;
+
+    updateLayout: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Spinner' {
+  declare var types: AnyObject<SpinnerType>;
+
+  declare var sizeMaps: AnyObject<
+    | {|
+        height: number,
+        width: number,
+        viewBox: void,
+        strokeWidth: number,
+      |}
+    | {|
+        height: number,
+        width: number,
+        viewBox: string,
+        strokeWidth: number,
+      |},
+  >;
+
+  declare function svgAnimateSupport(): boolean;
+
+  declare var _default: {|
+    types: AnyObject<SpinnerType>,
+    sizeMaps: AnyObject<
+      | {|
+          height: number,
+          width: number,
+          viewBox: void,
+          strokeWidth: number,
+        |}
+      | {|
+          height: number,
+          width: number,
+          viewBox: string,
+          strokeWidth: number,
+        |},
+    >,
+    svgAnimateSupport: typeof svgAnimateSupport,
+  |};
+
+  declare var SpinnerConfig: {|
+    hasSvgAnimationSupport: boolean,
+  |};
+
+  declare export type SpinnerType = _SpinnerType;
+
+  declare export type SpinnerProps = _SpinnerProps;
+
+  declare export default class Spinner extends React$Component<SpinnerProps> {
+    static Types: typeof types;
+  }
+}
+
+declare module '@skbkontur/react-ui/Sticky' {
+  declare export type StickyProps = {|
+    side: 'top' | 'bottom',
+    offset?: number,
+    getStop?: () => ?HTMLElement,
+    children?: React$Node | ((fixed: boolean) => React$Node),
+    allowChildWithMargins?: boolean,
+  |};
+
+  declare export type StickyState = {|
+    fixed: boolean,
+    height: number,
+    left: number | string,
+    width: number | string,
+    stopped: boolean,
+    relativeTop: number,
+  |};
+
+  declare export default class Sticky extends React$Component<
+    StickyProps,
+    StickyState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Switcher' {
+  declare export type SwitcherProps = {|
+    items: $ReadOnlyArray<string | SwitcherItem>,
+    value?: string,
+    onChange?: (
+      event: {|
+        target: {|
+          value: string,
+        |},
+      |},
+      value: string,
+    ) => void,
+    label?: string,
+    error?: boolean,
+  |};
+
+  declare export type SwitcherState = {|
+    focusedIndex: ?number,
+  |};
+
+  declare export type SwitcherItem = {|
+    label: string,
+    value: string,
+  |};
+
+  declare export default class Switcher extends React$Component<
+    SwitcherProps,
+    SwitcherState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Tabs' {
+  declare export type TabIndicators = {|
+    error: boolean,
+    warning: boolean,
+    success: boolean,
+    primary: boolean,
+    disabled: boolean,
+  |};
+
+  declare export type TabProps = {|
+    children?: React$Node,
+    // eslint-disable-next-line flowtype/no-weak-types
+    component?: React$ComponentType<any> | string,
+    href?: string,
+    id?: string,
+    onClick?: (event: SyntheticMouseEvent<HTMLElement>) => void,
+    onKeyDown?: (event: SyntheticKeyboardEvent<HTMLElement>) => void,
+    disabled?: boolean,
+    error?: boolean,
+    warning?: boolean,
+    success?: boolean,
+    primary?: boolean,
+    style?: Style,
+  |};
+
+  declare export type TabContext = {|
+    activeTab: string,
+    // eslint-disable-next-line flowtype/no-weak-types
+    addTab: (id: string, getNode: () => any) => void,
+    notifyUpdate: () => void,
+    removeTab: (id: string) => void,
+    shiftFocus: (fromTab: string, delta: number) => void,
+    switchTab: (id: string) => void,
+    vertical: boolean,
+  |};
+
+  declare export type TabState = {|
+    focusedByKeyboard: boolean,
+  |};
+
+  declare class Tab extends React$Component<TabProps, TabState> {
+    // eslint-disable-next-line flowtype/no-weak-types
+    getUnderlyingNode: () => ?React$Element<any>;
+  }
+
+  declare export type TabsProps = {|
+    children?: React$Node,
+    indicatorClassName?: string,
+    onChange?: (
+      ev: {|
+        target: {|
+          value: string,
+        |},
+      |},
+      value: string,
+    ) => void,
+    value: string,
+    vertical?: boolean,
+    width?: number | string,
+  |};
+
+  declare export type TabsState = {|
+    tabs: $ReadOnlyArray<{|
+      getNode: () => Tab | null,
+      id: string,
+    |}>,
+  |};
+
+  declare export default class Tabs extends React$Component<
+    TabsProps,
+    TabsState,
+  > {
+    static Tab: typeof Tab;
+  }
+}
+
+declare module '@skbkontur/react-ui/Textarea' {
+  declare var TextareaAdapter: {|
+    getValue(inst: Textarea): string | number | $ReadOnlyArray<string> | void,
+    setValue(inst: Textarea, value: string): void,
+  |};
+
+  declare export type TextareaProps = {
+    error?: boolean,
+    warning?: boolean,
+    disabled?: boolean,
+    autoResize?: boolean,
+    rows?: number,
+    maxRows?: string | number,
+    resize?: string,
+    width?: string | number,
+    onChange?: (
+      event: SyntheticInputEvent<HTMLTextAreaElement>,
+      value: string,
+    ) => void,
+    selectAllOnFocus?: boolean,
+    ...
+  };
+
+  declare export type TextareaState = {|
+    polyfillPlaceholder: boolean,
+    rows: number | string,
+  |};
+
+  declare export default class Textarea extends React$Component<
+    TextareaProps,
+    TextareaState,
+  > {
+    static __ADAPTER__: typeof TextareaAdapter;
+
+    focus(): void;
+    blur(): void;
+    setSelectionRange: (start: number, end: number) => void;
+    selectAll: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/ThemeConsumer' {
+  declare export type Theme = _Theme;
+
+  declare var ThemeConsumer: React$ComponentType<Theme>;
+
+  declare export default typeof ThemeConsumer;
+}
+
+declare module '@skbkontur/react-ui/ThemeProvider' {
+  declare export type Theme = _Theme;
+
+  declare export type ITheme = Theme;
+
+  declare export type IThemeIn = Theme;
+
+  declare export type ThemeProviderProps = {|
+    children: React$Node,
+    value: Theme,
+  |};
+
+  declare export default class ThemeProvider extends React$Component<ThemeProviderProps> {}
+}
+
+declare module '@skbkontur/react-ui/ThemeShowcase/ThemeShowcase' {
+  declare export type ShowcaseProps = {|
+    isDebugMode?: boolean,
+  |};
+
+  declare export type ShowcaseState = {|
+    selectedVariable?: _ComboBoxItem,
+  |};
+
+  declare export default class ThemeShowcase extends React$Component<
+    ShowcaseProps,
+    ShowcaseState,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Toast' {
+  declare export type ToastViewProps = {|
+    children?: string,
+    action?: ?{|
+      label: string,
+      handler: () => void,
+    |},
+    onClose?: () => void,
+    onMouseEnter?: () => void,
+    onMouseLeave?: () => void,
+  |};
+
+  declare class ToastView extends React$Component<ToastViewProps> {}
+
+  declare export type Action = {|
+    label: string,
+    handler: () => void,
+  |};
+
+  declare export type ToastState = {|
+    notification: ?string,
+    action: ?Action,
+    id: number,
+  |};
+
+  declare export type ToastProps = {|
+    onPush?: (notification: string, action?: Action) => void,
+    onClose?: (notification: string, action?: Action) => void,
+  |};
+
+  declare export default class Toast extends React$Component<
+    ToastProps,
+    ToastState,
+  > {
+    static push(notification: string, action?: Action): void;
+    static close(): void;
+
+    _toast: ?ToastView;
+    push(notification: string, action?: Action): void;
+    close: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Toggle' {
+  declare export type ToggleProps = {|
+    checked?: boolean,
+    defaultChecked?: boolean,
+    disabled?: boolean,
+    onChange?: (value: boolean) => void,
+    changeEventHandler?: InputEventHandler<HTMLInputElement>,
+    warning?: boolean,
+    error?: boolean,
+    loading?: boolean,
+    autoFocus?: boolean,
+    onFocus?: FocusEventHandler<HTMLInputElement>,
+    onBlur?: FocusEventHandler<HTMLInputElement>,
+    color?: string,
+  |};
+
+  declare export type ToggleState = {|
+    checked?: boolean,
+    focusByTab?: boolean,
+  |};
+
+  declare export default class Toggle extends React$Component<
+    ToggleProps,
+    ToggleState,
+  > {
+    focus: () => void;
+  }
+}
+
+declare module '@skbkontur/react-ui/Token' {
+  declare export type TokenColorName = _TokenColorName;
+
+  declare export type TokenColors = _TokenColors;
+
+  declare export type TokenActions = {|
+    onClick?: MouseEventHandler<HTMLDivElement>,
+    onRemove?: MouseEventHandler<HTMLElement>,
+  |};
+
+  declare export type TokenProps = _TokenProps;
+
+  declare var Token: React$ComponentType<{|
+    ...$Exact<TokenProps>,
+    ...$Exact<TokenActions>,
+  |}>;
+
+  declare export default typeof Token;
+}
+
+declare module '@skbkontur/react-ui/TokenInput' {
+  declare export type TokenInputType = 0 | 1 | 2;
+
+  declare export type TokenInputProps<T> = {|
+    selectedItems: $ReadOnlyArray<T>,
+    onChange: (items: $ReadOnlyArray<T>) => void,
+    autoFocus?: boolean,
+    type?: TokenInputType,
+    getItems?: (query: string) => Promise<$ReadOnlyArray<T>>,
+    hideMenuIfEmptyInputValue?: boolean,
+    renderItem: (item: T, state: _MenuItemState) => React$Node | void,
+    renderValue: (item: T) => React$Node,
+    renderNotFound: () => React$Node,
+    valueToItem: (item: string) => T,
+    placeholder?: string,
+    delimiters?: $ReadOnlyArray<string>,
+    error?: boolean,
+    warning?: boolean,
+    disabled?: boolean,
+    width: string | number,
+    renderTokenComponent?: (
+      token: (props?: $Shape<_TokenProps>) => React$Node,
+      value?: T,
+    ) => React$Node,
+  |};
+
+  declare export type TokenInputState<T> = {|
+    autocompleteItems?: $ReadOnlyArray<T>,
+    activeTokens: $ReadOnlyArray<T>,
+    inFocus?: boolean,
+    inputValue: string,
+    inputValueWidth: number,
+    preventBlur?: boolean,
+    loading?: boolean,
+  |};
+
+  declare export default class TokenInput<T = string> extends React$Component<
+    TokenInputProps<T>,
+    TokenInputState<T>,
+  > {}
+}
+
+declare module '@skbkontur/react-ui/Tooltip' {
+  declare export type TooltipTrigger =
+    | 'hover'
+    | 'click'
+    | 'focus'
+    | 'opened'
+    | 'closed'
+    | 'hoverAnchor';
+
+  declare export type TooltipProps = {|
+    anchorElement?: HTMLElement,
+    children?: React$Node,
+    className?: string,
+    closeButton?: boolean,
+    render?: ?() => React$Node,
+    pos: _PopupPosition,
+    trigger: TooltipTrigger,
+    onCloseClick?: MouseEventHandler<HTMLElement>,
+    onCloseRequest?: () => void,
+    allowedPositions?: $ReadOnlyArray<_PopupPosition>,
+    disableAnimations?: boolean,
+    useWrapper?: boolean,
+  |};
+
+  declare export type TooltipState = {|
+    opened: boolean,
+  |};
+
+  declare export default class Tooltip extends React$Component<
+    TooltipProps,
+    TooltipState,
+  > {
+    static closeDelay: number;
+
+    renderContent: () => React$Node;
+    renderCloseButton(): React$Node;
+  }
+}
+
+declare module '@skbkontur/react-ui/TooltipMenu' {
+  declare export type TooltipMenuChildType = React$Element<
+    React$ComponentType<_MenuItemProps | {||} | _MenuHeaderProps>,
+  >;
+
+  declare export type TooltipMenuProps = {|
+    children?: TooltipMenuChildType | $ReadOnlyArray<TooltipMenuChildType>,
+    menuMaxHeight?: number | string,
+    menuWidth?: number | string,
+    caption: $PropertyType<_PopupMenuProps, 'caption'>,
+    positions?: $ReadOnlyArray<string>,
+    disableAnimations: boolean,
+  |};
+
+  declare export default class TooltipMenu extends React$Component<TooltipMenuProps> {}
+}
+
+declare module '@skbkontur/react-ui/TopBar' {
+  declare class Logout extends React$Component<ButtonItemProps> {}
+
+  declare export type UserProps = {|
+    userName: string,
+    cabinetUrl?: string,
+  |};
+
+  declare class User extends React$Component<UserProps> {}
+
+  declare export type ButtonParams = {|
+    disabled?: boolean,
+    label: React$Node,
+    onClick: () => void,
+    onKeyDown: (event: SyntheticKeyboardEvent<HTMLElement>) => void,
+    opened: boolean,
+  |};
+
+  declare export type TopBarDropdownProps = {|
+    icon?: $PropertyType<_IconProps, 'name'>,
+    minWidth?: string | number | null,
+    use?: 'danger' | 'pay' | 'default',
+    label: React$Node,
+    onOpen?: () => void,
+    onClose?: () => void,
+  |};
+
+  declare class TopBarDropdown extends React$Component<TopBarDropdownProps> {}
+
+  declare export type OrganizationsProps = {|
+    caption: React$Node,
+    comment?: ?string,
+  |};
+
+  declare export type OrganizationsState = {|
+    captionWhiteSpace: string,
+    minWidth: ?number,
+  |};
+
+  declare class Organizations extends React$Component<
+    OrganizationsProps,
+    OrganizationsState,
+  > {}
+
+  declare class Divider extends React$Component<{||}> {}
+
+  declare class Icon extends React$Component<_IconProps> {
+    static getAllNames(): $ReadOnlyArray<string>;
+  }
+
+  declare export type ItemProps = {|
+    _onClick?: (event: SyntheticMouseEvent<HTMLDivElement>) => void,
+    _onKeyDown?: (event: SyntheticKeyboardEvent<HTMLDivElement>) => void,
+    active?: boolean,
+    children?: React$Node,
+    className?: string,
+    icon?: $PropertyType<_IconProps, 'name'>,
+    iconOnly?: boolean,
+    minWidth?: string | number,
+    use?: 'danger' | 'pay' | 'default',
+    tabIndex?: number,
+  |};
+
+  declare class Item extends React$Component<ItemProps> {}
+
+  declare export type IconName = $PropertyType<_IconProps, 'name'>;
+
+  declare export type ButtonItemProps = {|
+    ...$Exact<ItemProps>,
+    active?: boolean,
+    children?: React$Node,
+    className?: string,
+    icon?: IconName,
+    iconOnly?: boolean,
+    minWidth?: string | number,
+    onClick?: () => void,
+    onKeyDown?: (event: SyntheticKeyboardEvent<HTMLElement>) => void,
+    use?: 'danger' | 'pay' | 'default',
+  |};
+
+  declare class ButtonItem extends React$Component<ButtonItemProps> {}
+
+  declare export type TopBarProps = {|
+    children?: React$Node,
+    color?: string,
+    cabinetUrl?: string,
+    leftItems?: $ReadOnlyArray<React$Node>,
+    logoComponent?: React$ComponentType<any> | string,
+    logoHref?: string,
+    maxWidth?: string | number,
+    noMargin?: boolean,
+    noShadow?: boolean,
+    noWidget?: boolean,
+    onLogout?: () => void,
+    rightItems?: $ReadOnlyArray<React$Node>,
+    suffix?: string,
+    userName?: string,
+  |};
+
+  declare export type TopBarDefaultProps = {|
+    maxWidth: string | number,
+    rightItems: $ReadOnlyArray<React$Node>,
+  |};
+
+  declare export type TopBarStartProps = {|
+    children?: React$Node,
+  |};
+
+  declare export type TopBarEndProps = {|
+    children?: React$Node,
+  |};
+
+  declare export default class TopBar extends React$Component<TopBarProps> {
+    static Divider: typeof Divider;
+    static Item: typeof ButtonItem;
+    static Dropdown: typeof TopBarDropdown;
+    static OrganizationsDropdown: typeof Organizations;
+    static Start: React$ComponentType<TopBarStartProps>;
+    static End: React$ComponentType<TopBarEndProps>;
+    static ItemStatic: typeof Item;
+    static User: typeof User;
+    static Logout: typeof Logout;
+  }
+}
+
+declare module '@skbkontur/react-ui/ZIndex' {
+  declare export type ZIndexProps = {
+    delta: number,
+    render?: boolean,
+    className?: string,
+    ...
+  };
+
+  declare export default class ZIndex extends React$Component<ZIndexProps> {}
+}
diff --git a/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/test_react-ui_v1.x.x.js b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/test_react-ui_v1.x.x.js
new file mode 100644
index 0000000000..0137c11a3a
--- /dev/null
+++ b/definitions/npm/@skbkontur/react-ui_v1.x.x/flow_v0.201.x-/test_react-ui_v1.x.x.js
@@ -0,0 +1,13 @@
+/* @flow */
+import * as React from 'react';
+import { it, describe } from 'flow-typed-test';
+import Button from '@skbkontur/react-ui/Button';
+
+describe('react-ui', () => {
+  it('controls prop types', () => {
+    <Button>Button</Button>;
+
+    // $FlowExpectedError
+    <Button onClick={1}>Button</Button>;
+  });
+});
diff --git a/definitions/npm/apollo-client_v2.x.x/flow_v0.104.x-/apollo-client_v2.x.x.js b/definitions/npm/apollo-client_v2.x.x/flow_v0.104.x-v0.200.x/apollo-client_v2.x.x.js
similarity index 100%
rename from definitions/npm/apollo-client_v2.x.x/flow_v0.104.x-/apollo-client_v2.x.x.js
rename to definitions/npm/apollo-client_v2.x.x/flow_v0.104.x-v0.200.x/apollo-client_v2.x.x.js
diff --git a/definitions/npm/apollo-client_v2.x.x/flow_v0.201.x-/apollo-client_v2.x.x.js b/definitions/npm/apollo-client_v2.x.x/flow_v0.201.x-/apollo-client_v2.x.x.js
new file mode 100644
index 0000000000..d9b02b68ea
--- /dev/null
+++ b/definitions/npm/apollo-client_v2.x.x/flow_v0.201.x-/apollo-client_v2.x.x.js
@@ -0,0 +1,745 @@
+declare module "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 type OperationVariables = { [key: string]: any, ... };
+
+  declare export function print(ast: any): string;
+
+  declare export 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) => any
+    ): 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?: () => void,
+      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) => void) | 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) => void) | 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: NetworkStatusRaw,
+    error?: ApolloError,
+    partial?: boolean,
+    ...
+  };
+
+  declare export type ModifiableWatchQueryOptions = {
+    variables?: { [key: string]: any, ... },
+    pollInterval?: number,
+    fetchPolicy?: FetchPolicy,
+    errorPolicy?: ErrorPolicy,
+    fetchResults?: boolean,
+    notifyOnNetworkStatusChange?: boolean,
+    ...
+  }
+
+  declare export type WatchQueryOptions = {
+    ...$Exact<ModifiableWatchQueryOptions>,
+    query: DocumentNode,
+    metadata?: any,
+    context?: any,
+    ...
+  }
+
+  declare type RefetchQueryDescription = Array<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 type MutationOperation<T = Object> = (options: MutationBaseOptions<T>) => Promise<FetchResult<T>>
+
+  declare export interface MutationOptions<T = { [key: string]: any, ... }>
+    extends MutationBaseOptions<T> {
+    mutation: DocumentNode;
+    context?: any;
+    fetchPolicy?: FetchPolicy;
+  }
+
+  declare export type 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) => void,
+    ...
+  };
+
+  declare export type MutationUpdaterFn<T = OperationVariables> = (
+    proxy: DataProxy,
+    mutationResult: FetchResult<T>
+  ) => void;
+
+  declare export type NetworkStatusRaw = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+  declare export class NetworkStatus {
+    [NetworkStatusRaw]: string,
+    string: NetworkStatusRaw,
+  }
+
+  declare export type QueryListener = (
+    queryStoreValue: QueryStoreValue,
+    newData?: any
+  ) => void;
+
+  declare export type QueryStoreValue = {
+    document: DocumentNode,
+    variables: Object,
+    previousVariables: Object | null,
+    networkStatus: NetworkStatusRaw,
+    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: NetworkStatusRaw,
+    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: () => any): void;
+    __requestRaw(payload: GraphQLRequest): Observable<ExecutionResult<>>;
+    initQueryManager(): void;
+    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>;
+  }
+
+  declare export default typeof ApolloClient;
+
+  /* apollo-link types */
+  declare export 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) => void) | ZenObservableObserver<T>,
+      error?: (error: any) => void,
+      complete?: () => void
+    ): ZenObservableSubscription;
+
+    forEach(fn: (value: T) => void): 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) => any;
+    next?: (value: T) => void;
+    error?: (errorValue: any) => void;
+    complete?: () => void;
+  }
+
+  declare type ZenObservableSubscriber<T> = (
+    observer: ZenObservableSubscriptionObserver<T>
+  ) => void | (() => void) | SubscriptionLINK;
+
+  declare interface ZenObservableObservableLike<T> {
+    subscribe?: ZenObservableSubscriber<T>;
+  }
+  /* apollo-link types */
+
+  /* apollo-cache types */
+  declare export 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>) => void;
+
+  declare type CacheWatchCallback = (newData: any) => void;
+
+  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 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 */
+}
diff --git a/definitions/npm/axios_v0.19.x/flow_v0.104.x-/axios_v0.19.x.js b/definitions/npm/axios_v0.19.x/flow_v0.104.x-v0.200.x/axios_v0.19.x.js
similarity index 100%
rename from definitions/npm/axios_v0.19.x/flow_v0.104.x-/axios_v0.19.x.js
rename to definitions/npm/axios_v0.19.x/flow_v0.104.x-v0.200.x/axios_v0.19.x.js
diff --git a/definitions/npm/axios_v0.19.x/flow_v0.104.x-/test_axios_v0.19.x.js b/definitions/npm/axios_v0.19.x/flow_v0.104.x-v0.200.x/test_axios_v0.19.x.js
similarity index 100%
rename from definitions/npm/axios_v0.19.x/flow_v0.104.x-/test_axios_v0.19.x.js
rename to definitions/npm/axios_v0.19.x/flow_v0.104.x-v0.200.x/test_axios_v0.19.x.js
diff --git a/definitions/npm/axios_v0.20.x/flow_v0.83.x-/axios_v0.20.x.js b/definitions/npm/axios_v0.19.x/flow_v0.201.x-/axios_v0.19.x.js
similarity index 100%
rename from definitions/npm/axios_v0.20.x/flow_v0.83.x-/axios_v0.20.x.js
rename to definitions/npm/axios_v0.19.x/flow_v0.201.x-/axios_v0.19.x.js
diff --git a/definitions/npm/axios_v0.20.x/flow_v0.83.x-/test_axios_v0.20.x.js b/definitions/npm/axios_v0.19.x/flow_v0.201.x-/test_axios_v0.19.x.js
similarity index 100%
rename from definitions/npm/axios_v0.20.x/flow_v0.83.x-/test_axios_v0.20.x.js
rename to definitions/npm/axios_v0.19.x/flow_v0.201.x-/test_axios_v0.19.x.js
diff --git a/definitions/npm/axios_v0.21.x/flow_v0.83.x-/axios_v0.21.x.js b/definitions/npm/axios_v0.20.x/flow_v0.201.x-/axios_v0.20.x.js
similarity index 100%
rename from definitions/npm/axios_v0.21.x/flow_v0.83.x-/axios_v0.21.x.js
rename to definitions/npm/axios_v0.20.x/flow_v0.201.x-/axios_v0.20.x.js
diff --git a/definitions/npm/axios_v0.21.x/flow_v0.83.x-/test_axios_v0.21.x.js b/definitions/npm/axios_v0.20.x/flow_v0.201.x-/test_axios_v0.20.x.js
similarity index 100%
rename from definitions/npm/axios_v0.21.x/flow_v0.83.x-/test_axios_v0.21.x.js
rename to definitions/npm/axios_v0.20.x/flow_v0.201.x-/test_axios_v0.20.x.js
diff --git a/definitions/npm/axios_v0.22.x/flow_v0.83.x-/axios_v0.22.x.js b/definitions/npm/axios_v0.20.x/flow_v0.83.x-v0.200.x/axios_v0.20.x.js
similarity index 100%
rename from definitions/npm/axios_v0.22.x/flow_v0.83.x-/axios_v0.22.x.js
rename to definitions/npm/axios_v0.20.x/flow_v0.83.x-v0.200.x/axios_v0.20.x.js
diff --git a/definitions/npm/axios_v0.22.x/flow_v0.83.x-/test_axios_v0.22.x.js b/definitions/npm/axios_v0.20.x/flow_v0.83.x-v0.200.x/test_axios_v0.20.x.js
similarity index 100%
rename from definitions/npm/axios_v0.22.x/flow_v0.83.x-/test_axios_v0.22.x.js
rename to definitions/npm/axios_v0.20.x/flow_v0.83.x-v0.200.x/test_axios_v0.20.x.js
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.83.x-/axios_v0.23.x.js b/definitions/npm/axios_v0.21.x/flow_v0.201.x-/axios_v0.21.x.js
similarity index 100%
rename from definitions/npm/axios_v0.23.x/flow_v0.83.x-/axios_v0.23.x.js
rename to definitions/npm/axios_v0.21.x/flow_v0.201.x-/axios_v0.21.x.js
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.83.x-/test_axios_v0.23.x.js b/definitions/npm/axios_v0.21.x/flow_v0.201.x-/test_axios_v0.21.x.js
similarity index 100%
rename from definitions/npm/axios_v0.23.x/flow_v0.83.x-/test_axios_v0.23.x.js
rename to definitions/npm/axios_v0.21.x/flow_v0.201.x-/test_axios_v0.21.x.js
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.83.x-/axios_v0.24.x.js b/definitions/npm/axios_v0.21.x/flow_v0.83.x-v0.200.x/axios_v0.21.x.js
similarity index 100%
rename from definitions/npm/axios_v0.24.x/flow_v0.83.x-/axios_v0.24.x.js
rename to definitions/npm/axios_v0.21.x/flow_v0.83.x-v0.200.x/axios_v0.21.x.js
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.83.x-/test_axios_v0.24.x.js b/definitions/npm/axios_v0.21.x/flow_v0.83.x-v0.200.x/test_axios_v0.21.x.js
similarity index 100%
rename from definitions/npm/axios_v0.24.x/flow_v0.83.x-/test_axios_v0.24.x.js
rename to definitions/npm/axios_v0.21.x/flow_v0.83.x-v0.200.x/test_axios_v0.21.x.js
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.83.x-/axios_v0.25.x.js b/definitions/npm/axios_v0.22.x/flow_v0.201.x-/axios_v0.22.x.js
similarity index 100%
rename from definitions/npm/axios_v0.25.x/flow_v0.83.x-/axios_v0.25.x.js
rename to definitions/npm/axios_v0.22.x/flow_v0.201.x-/axios_v0.22.x.js
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.83.x-/test_axios_v0.25.x.js b/definitions/npm/axios_v0.22.x/flow_v0.201.x-/test_axios_v0.22.x.js
similarity index 100%
rename from definitions/npm/axios_v0.25.x/flow_v0.83.x-/test_axios_v0.25.x.js
rename to definitions/npm/axios_v0.22.x/flow_v0.201.x-/test_axios_v0.22.x.js
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.83.x-/axios_v0.26.x.js b/definitions/npm/axios_v0.22.x/flow_v0.83.x-v0.200.x/axios_v0.22.x.js
similarity index 100%
rename from definitions/npm/axios_v0.26.x/flow_v0.83.x-/axios_v0.26.x.js
rename to definitions/npm/axios_v0.22.x/flow_v0.83.x-v0.200.x/axios_v0.22.x.js
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.83.x-/test_axios_v0.26.x.js b/definitions/npm/axios_v0.22.x/flow_v0.83.x-v0.200.x/test_axios_v0.22.x.js
similarity index 100%
rename from definitions/npm/axios_v0.26.x/flow_v0.83.x-/test_axios_v0.26.x.js
rename to definitions/npm/axios_v0.22.x/flow_v0.83.x-v0.200.x/test_axios_v0.22.x.js
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.201.x-/axios_v0.23.x.js b/definitions/npm/axios_v0.23.x/flow_v0.201.x-/axios_v0.23.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.23.x/flow_v0.201.x-/axios_v0.23.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.201.x-/test_axios_v0.23.x.js b/definitions/npm/axios_v0.23.x/flow_v0.201.x-/test_axios_v0.23.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.23.x/flow_v0.201.x-/test_axios_v0.23.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/axios_v0.23.x.js b/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/axios_v0.23.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/axios_v0.23.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/test_axios_v0.23.x.js b/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/test_axios_v0.23.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.23.x/flow_v0.83.x-v0.200.x/test_axios_v0.23.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.201.x-/axios_v0.24.x.js b/definitions/npm/axios_v0.24.x/flow_v0.201.x-/axios_v0.24.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.24.x/flow_v0.201.x-/axios_v0.24.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.201.x-/test_axios_v0.24.x.js b/definitions/npm/axios_v0.24.x/flow_v0.201.x-/test_axios_v0.24.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.24.x/flow_v0.201.x-/test_axios_v0.24.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/axios_v0.24.x.js b/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/axios_v0.24.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/axios_v0.24.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/test_axios_v0.24.x.js b/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/test_axios_v0.24.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.24.x/flow_v0.83.x-v0.200.x/test_axios_v0.24.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.201.x-/axios_v0.25.x.js b/definitions/npm/axios_v0.25.x/flow_v0.201.x-/axios_v0.25.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.25.x/flow_v0.201.x-/axios_v0.25.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.201.x-/test_axios_v0.25.x.js b/definitions/npm/axios_v0.25.x/flow_v0.201.x-/test_axios_v0.25.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.25.x/flow_v0.201.x-/test_axios_v0.25.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/axios_v0.25.x.js b/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/axios_v0.25.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/axios_v0.25.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/test_axios_v0.25.x.js b/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/test_axios_v0.25.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.25.x/flow_v0.83.x-v0.200.x/test_axios_v0.25.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.201.x-/axios_v0.26.x.js b/definitions/npm/axios_v0.26.x/flow_v0.201.x-/axios_v0.26.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.26.x/flow_v0.201.x-/axios_v0.26.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.201.x-/test_axios_v0.26.x.js b/definitions/npm/axios_v0.26.x/flow_v0.201.x-/test_axios_v0.26.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.26.x/flow_v0.201.x-/test_axios_v0.26.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/axios_v0.26.x.js b/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/axios_v0.26.x.js
new file mode 100644
index 0000000000..9125c9be4e
--- /dev/null
+++ b/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/axios_v0.26.x.js
@@ -0,0 +1,222 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare class Cancel {
+    constructor(message?: string): Cancel;
+    message: string;
+  }
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel>;
+    reason?: Cancel;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/test_axios_v0.26.x.js b/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/test_axios_v0.26.x.js
new file mode 100644
index 0000000000..d463de4954
--- /dev/null
+++ b/definitions/npm/axios_v0.26.x/flow_v0.83.x-v0.200.x/test_axios_v0.26.x.js
@@ -0,0 +1,455 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
diff --git a/definitions/npm/axios_v0.27.x/flow_v0.83.x-/axios_v0.27.x.js b/definitions/npm/axios_v0.27.x/flow_v0.201.x-/axios_v0.27.x.js
similarity index 100%
rename from definitions/npm/axios_v0.27.x/flow_v0.83.x-/axios_v0.27.x.js
rename to definitions/npm/axios_v0.27.x/flow_v0.201.x-/axios_v0.27.x.js
diff --git a/definitions/npm/axios_v0.27.x/flow_v0.83.x-/test_axios_v0.27.x.js b/definitions/npm/axios_v0.27.x/flow_v0.201.x-/test_axios_v0.27.x.js
similarity index 100%
rename from definitions/npm/axios_v0.27.x/flow_v0.83.x-/test_axios_v0.27.x.js
rename to definitions/npm/axios_v0.27.x/flow_v0.201.x-/test_axios_v0.27.x.js
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.83.x-/axios_v1.x.x.js b/definitions/npm/axios_v0.27.x/flow_v0.83.x-v0.200.x/axios_v0.27.x.js
similarity index 100%
rename from definitions/npm/axios_v1.x.x/flow_v0.83.x-/axios_v1.x.x.js
rename to definitions/npm/axios_v0.27.x/flow_v0.83.x-v0.200.x/axios_v0.27.x.js
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.83.x-/test_axios_v1.x.x.js b/definitions/npm/axios_v0.27.x/flow_v0.83.x-v0.200.x/test_axios_v0.27.x.js
similarity index 100%
rename from definitions/npm/axios_v1.x.x/flow_v0.83.x-/test_axios_v1.x.x.js
rename to definitions/npm/axios_v0.27.x/flow_v0.83.x-v0.200.x/test_axios_v0.27.x.js
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.201.x-/axios_v1.x.x.js b/definitions/npm/axios_v1.x.x/flow_v0.201.x-/axios_v1.x.x.js
new file mode 100644
index 0000000000..8378051c1e
--- /dev/null
+++ b/definitions/npm/axios_v1.x.x/flow_v0.201.x-/axios_v1.x.x.js
@@ -0,0 +1,242 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel<mixed>>;
+    reason?: Cancel<mixed>;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    static ERR_NETWORK: string;
+    static ERR_BAD_OPTION_VALUE: string;
+    static ERR_BAD_OPTION: string;
+    static ECONNABORTED: string;
+    static ETIMEDOUT: string;
+    static ERR_NETWORK: string;
+    static ERR_FR_TOO_MANY_REDIRECTS: string;
+    static ERR_DEPRECATED: string;
+    static ERR_BAD_RESPONSE: string;
+    static ERR_BAD_REQUEST: string;
+    static ERR_CANCELED: string;
+
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+    status?: string;
+  }
+
+  declare class CanceledError<T> extends AxiosError<T> {
+  }
+
+  declare class Cancel<T> extends AxiosError<T> {
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    AxiosError: typeof AxiosError;
+    CanceledError: typeof CanceledError;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+    toFormData: (
+      obj: { [key: string]: any, ... },
+      formData?: FormData,
+    ) => FormData;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.201.x-/test_axios_v1.x.x.js b/definitions/npm/axios_v1.x.x/flow_v0.201.x-/test_axios_v1.x.x.js
new file mode 100644
index 0000000000..7a866cf43c
--- /dev/null
+++ b/definitions/npm/axios_v1.x.x/flow_v0.201.x-/test_axios_v1.x.x.js
@@ -0,0 +1,499 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios, { AxiosError, toFormData } from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
+
+describe('formData', () => {
+  it('returns FormData', () => {
+    const form = toFormData({
+      val: 123,
+      nested: {
+        arr: ['hello', 'world']
+      }
+    });
+
+    form.keys();
+    form.get('val');
+    form.getAll('arr[]');
+
+    // $FlowExpectedError[incompatible-call]
+    toFormData();
+    // $FlowExpectedError[incompatible-call] takes object as first arg
+    toFormData('');
+  });
+
+  it('can accept another FormData', () => {
+    declare var formData: FormData;
+    toFormData({}, formData);
+
+    // $FlowExpectedError[incompatible-call] second arg must be FormData type
+    toFormData({}, '');
+  });
+});
+
+describe('AxiosError', () => {
+  it('contains static error codes', () => {
+    (AxiosError.ERR_NETWORK: string);
+    (AxiosError.ERR_BAD_OPTION_VALUE: string);
+    (AxiosError.ERR_BAD_OPTION: string);
+    (AxiosError.ECONNABORTED: string);
+    (AxiosError.ETIMEDOUT: string);
+    (AxiosError.ERR_NETWORK: string);
+    (AxiosError.ERR_FR_TOO_MANY_REDIRECTS: string);
+    (AxiosError.ERR_DEPRECATED: string);
+    (AxiosError.ERR_BAD_RESPONSE: string);
+    (AxiosError.ERR_BAD_REQUEST: string);
+    (AxiosError.ERR_CANCELED: string);
+  });
+});
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/axios_v1.x.x.js b/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/axios_v1.x.x.js
new file mode 100644
index 0000000000..8378051c1e
--- /dev/null
+++ b/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/axios_v1.x.x.js
@@ -0,0 +1,242 @@
+declare module 'axios' {
+  import type { Agent as HttpAgent } from 'http';
+  import type { Agent as HttpsAgent } from 'https';
+
+  declare type AxiosTransformer<T> = (
+    data: T,
+    headers?: { [key: string]: mixed, ...},
+  ) => mixed;
+
+  declare type ProxyConfig = {|
+    host: string,
+    port: number,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    protocol?: string,
+  |};
+
+  declare type Canceler = (message?: string) => void;
+
+  declare type CancelTokenSource = {|
+    token: CancelToken,
+    cancel: Canceler,
+  |};
+
+  declare class CancelToken {
+    constructor(executor: (cancel: Canceler) => void): void;
+    static source(): CancelTokenSource;
+    promise: Promise<Cancel<mixed>>;
+    reason?: Cancel<mixed>;
+    throwIfRequested(): void;
+  }
+
+  declare type Method =
+    | 'get'
+    | 'GET'
+    | 'delete'
+    | 'DELETE'
+    | 'head'
+    | 'HEAD'
+    | 'options'
+    | 'OPTIONS'
+    | 'post'
+    | 'POST'
+    | 'put'
+    | 'PUT'
+    | 'patch'
+    | 'PATCH';
+
+  declare type ResponseType =
+    | 'arraybuffer'
+    | 'blob'
+    | 'document'
+    | 'json'
+    | 'text'
+    | 'stream';
+
+  declare type AxiosAdapter = (
+    config: AxiosXHRConfig<mixed>
+  ) => Promise<AxiosXHR<mixed>>;
+
+  declare type AxiosXHRConfigBase<T, R = T> = {
+    adapter?: AxiosAdapter,
+    auth?: {|
+      username: string,
+      password: string,
+    |},
+    baseURL?: string,
+    cancelToken?: CancelToken,
+    headers?: { [key: string]: mixed, ...},
+    httpAgent?: HttpAgent,
+    httpsAgent?: HttpsAgent,
+    maxContentLength?: number,
+    maxRedirects?: number,
+    socketPath?: string | null,
+    params?: { [key: string]: mixed, ...},
+    paramsSerializer?: (params: { [key: string]: mixed, ...}) => string,
+    onUploadProgress?: (progressEvent: ProgressEvent) => void,
+    onDownloadProgress?: (progressEvent: ProgressEvent) => void,
+    proxy?: ProxyConfig | false,
+    responseType?: ResponseType,
+    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 AxiosXHRConfig<T, R = T> = {
+    ...$Exact<AxiosXHRConfigBase<T, R>>,
+    data?: T,
+    method?: Method,
+    url: string,
+    ...
+  };
+
+  declare type AxiosXHRConfigShape<T, R = T> = $Shape<AxiosXHRConfig<T, R>>;
+
+  declare type AxiosXHR<T, R = T> = {|
+    config: AxiosXHRConfig<T, R>,
+    data: R,
+    headers: ?{[key: string]: mixed, ...},
+    status: number,
+    statusText: string,
+    request: http$ClientRequest<> | XMLHttpRequest | mixed,
+  |};
+
+  declare type AxiosInterceptorIdent = number;
+
+  declare type AxiosRequestInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(
+        response: AxiosXHRConfig<T, R>
+      ) => Promise<AxiosXHRConfig<mixed>> | AxiosXHRConfig<mixed>,
+      onRejected: ?(error: mixed) => mixed
+    ): AxiosInterceptorIdent,
+    eject(ident: AxiosInterceptorIdent): void,
+  |};
+
+  declare type AxiosResponseInterceptor<T, R = T> = {|
+    use(
+      onFulfilled: ?(response: AxiosXHR<T, R>) => mixed,
+      onRejected: ?(error: mixed) => 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?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    constructor<T, R>(config?: AxiosXHRConfigBase<T, R>): void;
+    request<T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    delete<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    get<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    head<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    options<R>(
+      url: string,
+      config?: AxiosXHRConfigBase<mixed, R>
+    ): AxiosPromise<mixed, R>;
+    post<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    put<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    patch<T, R>(
+      url: string,
+      data?: T,
+      config?: AxiosXHRConfigBase<T, R>
+    ): AxiosPromise<T, R>;
+    interceptors: {|
+      request: AxiosRequestInterceptor<mixed>,
+      response: AxiosResponseInterceptor<mixed>,
+    |};
+    defaults: {|
+      ...$Exact<AxiosXHRConfigBase<mixed>>,
+      headers: { [key: string]: mixed, ...},
+    |};
+    getUri<T, R>(config?: AxiosXHRConfig<T, R>): string;
+  }
+
+  declare class AxiosError<T, R = T> extends Error {
+    static ERR_NETWORK: string;
+    static ERR_BAD_OPTION_VALUE: string;
+    static ERR_BAD_OPTION: string;
+    static ECONNABORTED: string;
+    static ETIMEDOUT: string;
+    static ERR_NETWORK: string;
+    static ERR_FR_TOO_MANY_REDIRECTS: string;
+    static ERR_DEPRECATED: string;
+    static ERR_BAD_RESPONSE: string;
+    static ERR_BAD_REQUEST: string;
+    static ERR_CANCELED: string;
+
+    config: AxiosXHRConfig<T, R>;
+    request?: http$ClientRequest<> | XMLHttpRequest;
+    response?: AxiosXHR<T, R>;
+    code?: string;
+    isAxiosError: boolean;
+    status?: string;
+  }
+
+  declare class CanceledError<T> extends AxiosError<T> {
+  }
+
+  declare class Cancel<T> extends AxiosError<T> {
+  }
+
+  declare interface AxiosExport extends Axios {
+    <T, R>(
+      config: AxiosXHRConfig<T, R> | string,
+      config?: AxiosXHRConfigShape<T, R>
+    ): AxiosPromise<T, R>;
+    Axios: typeof Axios;
+    AxiosError: typeof AxiosError;
+    CanceledError: typeof CanceledError;
+    Cancel: typeof Cancel;
+    CancelToken: typeof CancelToken;
+    isCancel(value: mixed): boolean;
+    create<T, R>(config?: AxiosXHRConfigBase<T, R>): Axios;
+    all: typeof Promise.all;
+    spread<T, R>(callback: (...args: T) => R): (array: T) => R;
+    toFormData: (
+      obj: { [key: string]: any, ... },
+      formData?: FormData,
+    ) => FormData;
+  }
+
+  declare type $AxiosXHRConfigBase<T, R = T> = AxiosXHRConfigBase<T, R>;
+
+  declare type $AxiosXHRConfig<T, R = T> = AxiosXHRConfig<T, R>;
+
+  declare type $AxiosXHR<T, R = T> = AxiosXHR<T, R>;
+
+  declare type $AxiosError<T, R = T> = AxiosError<T, R>;
+
+  declare module.exports: AxiosExport;
+}
diff --git a/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/test_axios_v1.x.x.js b/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/test_axios_v1.x.x.js
new file mode 100644
index 0000000000..7a866cf43c
--- /dev/null
+++ b/definitions/npm/axios_v1.x.x/flow_v0.83.x-v0.200.x/test_axios_v1.x.x.js
@@ -0,0 +1,499 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import axios, { AxiosError, toFormData } from 'axios';
+import type {
+  $AxiosError,
+  $AxiosXHR,
+  $AxiosXHRConfig,
+  $AxiosXHRConfigBase,
+  Axios,
+  AxiosAdapter,
+  Canceler,
+  CancelTokenSource,
+} from 'axios';
+
+type User = {|
+  +id: number,
+  +name: string,
+|};
+
+type RequestDataUser = {|
+  +name: string,
+|};
+
+type Header = {[key: string]: mixed,...};
+
+const handleResponse = (response: $AxiosXHR<mixed>) => {
+  (response.data: mixed);
+  (response.status: number);
+  // $FlowExpectedError[incompatible-cast]
+  (response.status: string);
+  (response.statusText: string);
+  // $FlowExpectedError[incompatible-cast]
+  (response.statusText: number);
+  (response.headers: ?{...});
+  (response.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (response.config: string);
+};
+
+const handleUserResponse = (
+  response: $AxiosXHR<mixed, User> | $AxiosXHR<RequestDataUser, User>
+) => {
+  (response.data.id: number);
+  (response.data.name: string);
+};
+
+const handleError = (error: $AxiosError<mixed>) => {
+  (error: Error);
+  (error.isAxiosError: boolean);
+  // $FlowExpectedError[incompatible-cast]
+  (error.isAxiosError: number);
+
+  (error.config: $AxiosXHRConfig<mixed>);
+  // $FlowExpectedError[incompatible-cast]
+  (error.config: string);
+
+  if (error.response) {
+    (error.response.data: mixed);
+    (error.response.status: number);
+    (error.response.headers: ?{...});
+  } else {
+    (error.message: string);
+  }
+};
+
+const config: $AxiosXHRConfigBase<RequestDataUser, User> = {
+  baseURL: 'https://api.example.com/',
+  transformRequest: (data: RequestDataUser, headers?: Header) => '{"foo":"bar"}',
+  transformResponse: [(data: User, headers?: Header) => ({ baz: 'qux' })],
+  headers: { 'X-FOO': 'bar' },
+  params: { id: 12345 },
+  paramsSerializer: (params: Object) => 'id=12345',
+  timeout: 10000,
+  withCredentials: true,
+  auth: {
+    username: 'janedoe',
+    password: 's00pers3cret',
+  },
+  responseType: 'json',
+  xsrfCookieName: 'XSRF-TOKEN',
+  xsrfHeaderName: 'X-XSRF-TOKEN',
+  onUploadProgress: (progressEvent: any) => {},
+  onDownloadProgress: (progressEvent: any) => {},
+  maxContentLength: 2000,
+  validateStatus: (status: number) => status >= 200 && status < 300,
+  maxRedirects: 5,
+  proxy: {
+    host: '127.0.0.1',
+    port: 9000,
+  },
+  cancelToken: new axios.CancelToken((cancel: Canceler) => {}),
+};
+
+describe('Config', () => {
+  it('Axios Config', () => {
+    const axiosConfig: $AxiosXHRConfig<RequestDataUser, User> = {
+      ...config,
+      url: '/user',
+      data: { name: 'new name' },
+      method: 'PUT',
+    };
+
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.method = 'FOOBAR';
+    // $FlowExpectedError[incompatible-type]
+    axiosConfig.responseType = 'foobar';
+  });
+});
+
+describe('Headers', () => {
+  it('should take inexact kv pairs with string type as key and mixed type as values', () => {
+    const test: Header = { 'foo': 1 };
+    const test1: Header = { 'bar': 'baz'};
+
+    // $FlowExpectedError[unsupported-syntax]
+    const test2: Header = { 1 : 'false'}
+  });
+})
+
+describe('Request methods', () => {
+  it('returns a promise', () => {
+    axios({
+      url: '/user',
+      method: 'get',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios('/user', {
+      method: 'post',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .delete('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .head('/user')
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .patch('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user?id=12345')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .get<User>('/user', { params: { id: 12345 } })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .head<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .delete<User>('/user')
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .post<RequestDataUser, User>(
+        '/user',
+        { name: 'new name' },
+        { headers: { 'X-FOO': 'bar' } }
+      )
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .put<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+
+    axios
+      .patch<RequestDataUser, User>('/user', { name: 'new name' })
+      .then(handleUserResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Create instance', () => {
+  it('returns a callable axios instance', () => {
+    const instance1: Axios = axios.create();
+    const instance2: Axios = axios.create(config);
+
+    instance1('/user', {
+      method: 'POST',
+    })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .request({
+        url: '/user',
+        method: 'POST',
+      })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user?id=12345')
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .get('/user', { params: { id: 12345 } })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    instance1
+      .post('/user', { foo: 'bar' }, { headers: { 'X-FOO': 'bar' } })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('Defaults', () => {
+  it('setters default config', () => {
+    axios.defaults.baseURL = 'https://api.example.com/';
+    axios.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    }
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }};
+    axios.defaults.timeout = 2500;
+
+    const instance: Axios = axios.create();
+    instance.defaults.baseURL = 'https://api.example.com/';
+    instance.defaults.headers = {
+      'common': {
+        'Authorization': 'token'
+      }
+    };
+    axios.defaults.headers =  {
+      'post': {
+        'X-FOO': 'bar'
+      }
+    };
+
+    instance.defaults.timeout = 2500;
+  });
+});
+
+describe('Interceptors', () => {
+  it('use a request interceptor', () => {
+    const requestInterceptorId: number = axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => config,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.eject(requestInterceptorId);
+
+    axios.interceptors.request.use(
+      (config: $AxiosXHRConfig<mixed>) => Promise.resolve(config),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) => config);
+    axios.interceptors.request.use((config: $AxiosXHRConfig<mixed>) =>
+      Promise.resolve(config)
+    );
+  });
+
+  it('use a response interceptor', () => {
+    const responseInterceptorId: number = axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => response,
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.eject(responseInterceptorId);
+
+    axios.interceptors.response.use(
+      (response: $AxiosXHR<mixed>) => Promise.resolve(response),
+      (error: mixed) => Promise.reject(error)
+    );
+
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) => response);
+    axios.interceptors.response.use((response: $AxiosXHR<mixed>) =>
+      Promise.resolve(response)
+    );
+  });
+});
+
+describe('Adapters', () => {
+  it('use adapter', () => {
+    const adapter: AxiosAdapter = (config: $AxiosXHRConfig<mixed>) => {
+      const response: $AxiosXHR<mixed> = {
+        data: { foo: 'bar' },
+        status: 200,
+        statusText: 'OK',
+        headers: { 'X-FOO': 'bar' },
+        config,
+        request: {},
+      };
+      return Promise.resolve(response);
+    };
+
+    axios.defaults.adapter = adapter;
+  });
+});
+
+describe('Concurrency', () => {
+  it('axios.all', () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    const promise: Promise<Array<number>> = axios.all(promises);
+    // $FlowExpectedError[incompatible-type-arg]
+    const promise2: Promise<Array<string>> = axios.all(promises);
+  });
+
+  it('axios.spread', () => {
+    const fn1 = (a: number, b: number, c: number) => `${a}-${b}-${c}`;
+    const fn2: (arr: Array<number>) => string = axios.spread(fn1);
+    // $FlowExpectedError[incompatible-type]
+    const fn3: (arr: Array<string>) => string = axios.spread(fn1);
+  });
+});
+
+describe('Cancellation', () => {
+  it('use a CancelToken', () => {
+    const source: CancelTokenSource = axios.CancelToken.source();
+
+    axios.get('/user', {
+      cancelToken: source.token,
+    });
+
+    // $FlowExpectedError[incompatible-call]
+    axios.get('/something', { cancelToken: source });
+
+    (source.cancel: Canceler);
+    source.cancel('Operation has been canceled.');
+    // $FlowExpectedError[incompatible-call]
+    source.cancel(42);
+  });
+});
+
+describe('Extended', () => {
+  it('create extended', () => {
+    class AxiosExtended extends axios.Axios {
+      specialPut(...args) {
+        return super.put(...args);
+      }
+    }
+
+    const extended = new AxiosExtended();
+
+    extended
+      .put('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+
+    extended
+      .specialPut('/user', { foo: 'bar' })
+      .then(handleResponse)
+      .catch(handleError);
+  });
+});
+
+describe('getUri', () => {
+  it('returns a string', () => {
+    const uri: string = axios.getUri({
+      method: 'post',
+      url: '/user/12345',
+      params: {
+        foo: 'bar',
+      },
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const uri2: number = axios.getUri();
+  });
+});
+
+describe('options', () => {
+  it('accepts string url only', () => {
+    //$FlowExpectedError[incompatible-call]
+    axios.options(123)
+    axios.options('a url')
+  });
+
+  it('takes a url and returns a promise', () => {
+    axios
+      .options('anyUrl')
+      .then(handleResponse)
+      .catch(handleError);
+  });
+
+  it('takes url and config, returns a promise', () => {
+    const axiosConfig:$AxiosXHRConfig<mixed> = {
+      url: '/foo',
+      method: 'OPTIONS',
+    };
+    axios
+      .options('a url', axiosConfig)
+      .then(handleResponse)
+      .catch(handleError)
+  });
+});
+
+describe('formData', () => {
+  it('returns FormData', () => {
+    const form = toFormData({
+      val: 123,
+      nested: {
+        arr: ['hello', 'world']
+      }
+    });
+
+    form.keys();
+    form.get('val');
+    form.getAll('arr[]');
+
+    // $FlowExpectedError[incompatible-call]
+    toFormData();
+    // $FlowExpectedError[incompatible-call] takes object as first arg
+    toFormData('');
+  });
+
+  it('can accept another FormData', () => {
+    declare var formData: FormData;
+    toFormData({}, formData);
+
+    // $FlowExpectedError[incompatible-call] second arg must be FormData type
+    toFormData({}, '');
+  });
+});
+
+describe('AxiosError', () => {
+  it('contains static error codes', () => {
+    (AxiosError.ERR_NETWORK: string);
+    (AxiosError.ERR_BAD_OPTION_VALUE: string);
+    (AxiosError.ERR_BAD_OPTION: string);
+    (AxiosError.ECONNABORTED: string);
+    (AxiosError.ETIMEDOUT: string);
+    (AxiosError.ERR_NETWORK: string);
+    (AxiosError.ERR_FR_TOO_MANY_REDIRECTS: string);
+    (AxiosError.ERR_DEPRECATED: string);
+    (AxiosError.ERR_BAD_RESPONSE: string);
+    (AxiosError.ERR_BAD_REQUEST: string);
+    (AxiosError.ERR_CANCELED: string);
+  });
+});
diff --git a/definitions/npm/cache-manager_v2.x.x/flow_v0.104.x-/cache-manager_v2.x.x.js b/definitions/npm/cache-manager_v2.x.x/flow_v0.104.x-v0.200.x/cache-manager_v2.x.x.js
similarity index 100%
rename from definitions/npm/cache-manager_v2.x.x/flow_v0.104.x-/cache-manager_v2.x.x.js
rename to definitions/npm/cache-manager_v2.x.x/flow_v0.104.x-v0.200.x/cache-manager_v2.x.x.js
diff --git a/definitions/npm/cache-manager_v2.x.x/flow_v0.201.x-/cache-manager_v2.x.x.js b/definitions/npm/cache-manager_v2.x.x/flow_v0.201.x-/cache-manager_v2.x.x.js
new file mode 100644
index 0000000000..d518c0ee0c
--- /dev/null
+++ b/definitions/npm/cache-manager_v2.x.x/flow_v0.201.x-/cache-manager_v2.x.x.js
@@ -0,0 +1,35 @@
+declare module 'cache-manager' {
+  declare type _CacheOptions = { ttl?: number, ... }
+  /*declare type CacheOptions = $Shape<_CacheOptions> | Object*/
+  declare type CacheOptions = Object
+  declare type CachingOptions = _CacheOptions & {
+    ignoreCacheErrors?: bool,
+    isCacheableValue?: (value: mixed) => bool,
+    // typeof Promise?
+    promiseDependency?: any,
+    max?: number,
+    //any because this can be specified by a lot
+    store: any,
+    ...
+  }
+  declare class Cache {
+    get(key: mixed, options?: CacheOptions): Promise<mixed>;
+    set(key: mixed, value: mixed, options?: CacheOptions): Promise<void>;
+    del(key: mixed, options?: CacheOptions): Promise<void>;
+    wrap(key: mixed, cb: (cacheCallback: Function) => mixed, options?: CacheOptions): Promise<any>;
+  }
+  declare class caching {
+    constructor(options?: CachingOptions): Cache;
+    static (options?: CachingOptions): Cache;
+  }
+  declare class multiCaching {
+    constructor(caches: Cache[], options?: CachingOptions): Cache;
+    static (caches: Cache[], options?: CachingOptions): Cache;
+  }
+  declare module.exports: {
+    Cache: typeof Cache,
+    caching: typeof caching,
+    multiCaching: typeof multiCaching,
+    ...
+  }
+}
diff --git a/definitions/npm/cb-fetch_v1.10.x/flow_v0.104.x-/cb-fetch_v1.10.x.js b/definitions/npm/cb-fetch_v1.10.x/flow_v0.104.x-v0.200.x/cb-fetch_v1.10.x.js
similarity index 100%
rename from definitions/npm/cb-fetch_v1.10.x/flow_v0.104.x-/cb-fetch_v1.10.x.js
rename to definitions/npm/cb-fetch_v1.10.x/flow_v0.104.x-v0.200.x/cb-fetch_v1.10.x.js
diff --git a/definitions/npm/cb-fetch_v1.10.x/flow_v0.201.x-/cb-fetch_v1.10.x.js b/definitions/npm/cb-fetch_v1.10.x/flow_v0.201.x-/cb-fetch_v1.10.x.js
new file mode 100644
index 0000000000..6c32ddc805
--- /dev/null
+++ b/definitions/npm/cb-fetch_v1.10.x/flow_v0.201.x-/cb-fetch_v1.10.x.js
@@ -0,0 +1,119 @@
+declare module 'cb-fetch' {
+
+  declare module.exports: typeof request;
+
+  declare type RequestBody =
+    | BodyInit
+    | Document
+
+  declare type Type =
+    |             'arraybuffer'
+    | 'moz-chunked-arraybuffer'
+    |             'blob'
+    |         'moz-blob'
+    |             'document'
+    |       'msxml-document'
+    |             'formdata'
+    |             'json'
+    |             'text'
+    | 'moz-chunked-text'
+
+  declare type Parameters =
+    | string
+    | { [string]: ?string | string[], ... }
+    | URLSearchParams
+
+  declare type RequestURL =
+    | string
+    | URL
+
+  declare type RequestOptions = {|
+    url: RequestURL;
+    method: string;
+    headers: HeadersInit;
+    parameters: Parameters;
+    body: RequestBody;
+    credentials: CredentialsType;
+    mode: ModeType;
+    responseType: Type;
+    responseMediaType: string;
+    timeout: number;
+    username: string;
+    password: string;
+    multipart: boolean;
+    tunneling: boolean;
+    XSLPattern: boolean;
+  |}
+
+  declare type JSONValue = null | void | string | number | boolean | $Shape<{ [string]: JSONValue, ... }> | Array<JSONValue>
+  declare class AnonXMLHttpRequest extends XMLHttpRequest {}
+
+  declare type NormalizedResponse<T> = {|
+    body: JSONValue | Blob | Document | FormData | ReadableStream | ArrayBuffer;
+    headers: { [string]: string, ... } | T;
+    instance: XMLHttpRequest | XDomainRequest | Response | AnonXMLHttpRequest;
+    statusCode?: number;
+    statusText?: string;
+    url?: string;
+  |}
+
+  declare type ProgressEvent = {|
+    chunk: string | ArrayBuffer | Blob | Uint8Array | null;
+    aggregate: string | ArrayBuffer | Blob | Uint8Array | null;
+    loaded: number;
+    total: number;
+    lengthComputable: boolean;
+  |}
+
+  declare type onSuccess = (response: NormalizedResponse<empty>) => any;
+  declare type onError   = (response: NormalizedResponse<void>) => any;
+  declare type Abort     = () => void
+
+  declare interface Done {
+    (onSuccess?: onSuccess, onError?: onError): Abort;
+    (callbacks?: {
+      success?: onSuccess,
+      error?:   onError,
+      timeout?: () => any,
+      abort?:   (event?: Event) => any,
+      ...
+    }): Abort;
+  }
+
+  declare type Tail = {|
+    hook: Hook;
+    done: Done;
+  |}
+
+  declare interface Hook {
+    (name: "loadstart", handler: () => boolean | void)         : Tail;
+    (name: "download",  handler: (event: ProgressEvent) => any): Tail;
+    (name: "loadend",   handler: () => any)                    : Tail;
+  }
+
+  declare type Querier = {|
+    query: (parameters?: Parameters) => Tail,
+    ...Tail
+  |}
+
+  declare type Sender = {|
+    send: (body?: RequestBody) => Tail,
+    ...Tail
+  |}
+
+  declare type Verb<T> = (url?: RequestURL) => T
+
+  declare type Methods = {|
+    get: Verb<Querier>,
+    delete: Verb<Querier>,
+    head: Verb<Querier>,
+    post: Verb<Sender>,
+    put: Verb<Sender>,
+    patch: Verb<Sender>,
+    ...Tail
+  |}
+
+  declare function request(options?: $Shape<RequestOptions>): Methods
+  declare function request(url?: RequestURL): Methods
+
+}
\ No newline at end of file
diff --git a/definitions/npm/cb-fetch_v1.11.x/flow_v0.104.x-/cb-fetch_v1.11.x.js b/definitions/npm/cb-fetch_v1.11.x/flow_v0.104.x-v0.200.x/cb-fetch_v1.11.x.js
similarity index 100%
rename from definitions/npm/cb-fetch_v1.11.x/flow_v0.104.x-/cb-fetch_v1.11.x.js
rename to definitions/npm/cb-fetch_v1.11.x/flow_v0.104.x-v0.200.x/cb-fetch_v1.11.x.js
diff --git a/definitions/npm/cb-fetch_v1.11.x/flow_v0.201.x-/cb-fetch_v1.11.x.js b/definitions/npm/cb-fetch_v1.11.x/flow_v0.201.x-/cb-fetch_v1.11.x.js
new file mode 100644
index 0000000000..f0f6056228
--- /dev/null
+++ b/definitions/npm/cb-fetch_v1.11.x/flow_v0.201.x-/cb-fetch_v1.11.x.js
@@ -0,0 +1,121 @@
+declare module 'cb-fetch' {
+
+    declare module.exports: typeof request;
+
+    declare type RequestBody =
+      | BodyInit
+      | Document
+
+    declare type Type =
+      |             'arraybuffer'
+      | 'moz-chunked-arraybuffer'
+      |             'blob'
+      |         'moz-blob'
+      |             'document'
+      |       'msxml-document'
+      |             'formdata'
+      |             'json'
+      |             'text'
+      | 'moz-chunked-text'
+
+    declare type Parameters =
+      | string
+      | { [string]: ?string | string[], ... }
+      | URLSearchParams
+
+    declare type RequestURL =
+      | string
+      | URL
+
+    declare type RequestOptions = {|
+      url: RequestURL;
+      method: string;
+      headers: HeadersInit;
+      parameters: Parameters;
+      body: RequestBody;
+      credentials: CredentialsType;
+      mode: ModeType;
+      responseType: Type;
+      responseMediaType: string;
+      timeout: number;
+      username: string;
+      password: string;
+      multipart: boolean;
+      tunneling: boolean;
+      XSLPattern: boolean;
+    |}
+
+    declare type JSONValue = null | void | string | number | boolean | $Shape<{ [string]: JSONValue, ... }> | Array<JSONValue>
+    declare class AnonXMLHttpRequest extends XMLHttpRequest {}
+
+    declare type NormalizedResponse<T> = {|
+      body: JSONValue | Blob | Document | FormData | ReadableStream | ArrayBuffer;
+      headers: { [string]: string, ... } | T;
+      instance: XMLHttpRequest | XDomainRequest | Response | AnonXMLHttpRequest;
+      statusCode?: number;
+      statusText?: string;
+      url?: string;
+    |}
+
+    declare type ProgressEvent = {|
+      chunk: string | ArrayBuffer | Blob | Uint8Array | null;
+      aggregate: string | ArrayBuffer | Blob | Uint8Array | null;
+      loaded: number;
+      total: number;
+      lengthComputable: boolean;
+    |}
+
+    declare type onSuccess = (response: NormalizedResponse<empty>) => any;
+    declare type onError   = (response: NormalizedResponse<void>) => any;
+    declare type Abort     = () => void
+
+    declare interface Done {
+      (onSuccess?: onSuccess, onError?: onError): Abort;
+      (callbacks?: {|
+        success?: onSuccess,
+        error?:   onError,
+        timeout?: () => any,
+        abort?:   (event?: Event) => any
+      |}): Abort;
+    }
+
+    declare interface Pass<T> {
+      (name: string, value: string): T;
+      (headers?: HeadersInit)      : T;
+    }
+
+    declare interface Hook<T> {
+      (name: "loadstart", handler: () => boolean | void)         : T;
+      (name: "download",  handler: (event: ProgressEvent) => any): T;
+      (name: "loadend",   handler: () => any)                    : T;
+    }
+
+    declare class Common {
+      hook: Hook<this>;
+      pass: Pass<this>;
+      done: Done;
+    }
+
+    declare class Querier extends Common {
+      query: (parameters?: Parameters) => Common;
+    }
+
+    declare class Sender extends Common {
+      send: (body?: RequestBody) => Common;
+    }
+
+    declare type Verb<T> = (url?: RequestURL) => T
+
+    declare class Methods extends Common {
+      get: Verb<Querier>;
+      delete: Verb<Querier>;
+      head: Verb<Querier>;
+      post: Verb<Sender>;
+      put: Verb<Sender>;
+      patch: Verb<Sender>;
+    }
+
+    declare function request(options?: $Shape<RequestOptions>): Methods
+    declare function request(url?: RequestURL): Methods
+
+  }
diff --git a/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-/combine-section-reducers_v1.x.x.js b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-v0.200.x/combine-section-reducers_v1.x.x.js
similarity index 100%
rename from definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-/combine-section-reducers_v1.x.x.js
rename to definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-v0.200.x/combine-section-reducers_v1.x.x.js
diff --git a/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-/test_combine-section-reducers.js b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-v0.200.x/test_combine-section-reducers.js
similarity index 100%
rename from definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-/test_combine-section-reducers.js
rename to definitions/npm/combine-section-reducers_v1.x.x/flow_v0.104.x-v0.200.x/test_combine-section-reducers.js
diff --git a/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/combine-section-reducers_v1.x.x.js b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/combine-section-reducers_v1.x.x.js
new file mode 100644
index 0000000000..9e9bb35d65
--- /dev/null
+++ b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/combine-section-reducers_v1.x.x.js
@@ -0,0 +1,15 @@
+declare module 'combine-section-reducers' {
+
+  /*
+    S = State
+    A = Action
+    E = EntireState
+  */
+
+  declare type Reducer<S, A> = (state: S, action: A, ...rest: any) => S;
+  declare type SectionReducer<S, A, E> = (state: S, action: A, entireState?: E) => S;
+  declare type CombinedSectionReducer<S, A, E> = (state: $Shape<S> & {...} | void, action: A, entireState?: E) => S;
+  declare function combineSectionReducers<O: Object, A, E>(reducers: O): CombinedSectionReducer<$ObjMap<O, <S>(r: Reducer<S, any>) => S>, A, E>;
+  declare module.exports: typeof combineSectionReducers;
+
+}
diff --git a/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/test_combine-section-reducers.js b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/test_combine-section-reducers.js
new file mode 100644
index 0000000000..cb1e40675f
--- /dev/null
+++ b/definitions/npm/combine-section-reducers_v1.x.x/flow_v0.201.x-/test_combine-section-reducers.js
@@ -0,0 +1,50 @@
+// @flow
+import type { SectionReducer, CombinedSectionReducer } from 'combine-section-reducers'
+import combineSectionReducers from 'combine-section-reducers'
+
+type Action = { type: 'A', ... } | { type: 'B', ... };
+type AState = { foo: number, ... };
+const initialAState: AState = { foo: 1 }
+const reducerA = (state = initialAState, action) => {
+  return state
+}
+type State = {
+  a: AState,
+  name: string,
+  age: number,
+  ...
+};
+
+//
+// combineReducers API
+//
+
+function reducerName(name: string, action: Action, entireState: State): string {
+  return name
+}
+
+function reducerAge(age: number, action: Action, entireState: State): number {
+  return age
+}
+
+const reducer0: CombinedSectionReducer<State, Action, State> = combineSectionReducers({
+  a: reducerA,
+  name: reducerName,
+  age: reducerAge
+})
+
+const superReducer: SectionReducer<{ data: State, ... }, Action, { data: State, ... }> = combineSectionReducers({
+  data: reducer0
+});
+
+// $FlowExpectedError
+combineSectionReducers() // wrong reducers argument
+// $FlowExpectedError
+combineSectionReducers([]) // wrong reducers argument
+
+// $FlowExpectedError
+const reducer1: SectionReducer<State, Action, State> = combineSectionReducers({
+  a: reducerA,
+  name: reducerName
+  // missing age reducer
+})
diff --git a/definitions/npm/decimal.js-light_v2.3.x/flow_v0.104.x-/decimal.js-light_v2.3.x.js b/definitions/npm/decimal.js-light_v2.3.x/flow_v0.104.x-v0.200.x/decimal.js-light_v2.3.x.js
similarity index 100%
rename from definitions/npm/decimal.js-light_v2.3.x/flow_v0.104.x-/decimal.js-light_v2.3.x.js
rename to definitions/npm/decimal.js-light_v2.3.x/flow_v0.104.x-v0.200.x/decimal.js-light_v2.3.x.js
diff --git a/definitions/npm/decimal.js-light_v2.4.x/flow_v0.104.x-/decimal.js-light_v2.4.x.js b/definitions/npm/decimal.js-light_v2.3.x/flow_v0.201.x-/decimal.js-light_v2.3.x.js
similarity index 100%
rename from definitions/npm/decimal.js-light_v2.4.x/flow_v0.104.x-/decimal.js-light_v2.4.x.js
rename to definitions/npm/decimal.js-light_v2.3.x/flow_v0.201.x-/decimal.js-light_v2.3.x.js
diff --git a/definitions/npm/decimal.js-light_v2.4.x/flow_v0.104.x-v0.200.x/decimal.js-light_v2.4.x.js b/definitions/npm/decimal.js-light_v2.4.x/flow_v0.104.x-v0.200.x/decimal.js-light_v2.4.x.js
new file mode 100644
index 0000000000..f78570252a
--- /dev/null
+++ b/definitions/npm/decimal.js-light_v2.4.x/flow_v0.104.x-v0.200.x/decimal.js-light_v2.4.x.js
@@ -0,0 +1,573 @@
+declare module 'decimal.js-light' {
+  declare type Numeric = string | number | Decimal;
+
+  declare type DecimalConfig = $Shape<{
+   precision: number,
+   rounding: number,
+   toExpNeg: number,
+   toExpPos: number,
+   LN10: Numeric,
+   ...
+  }>;
+
+  declare class Decimal {
+    /**
+     * The Decimal constructor and exported function.
+     * Return a new Decimal instance.
+     *
+     * @param value {number|string|Decimal} A numeric value.
+     *
+     */
+    constructor(value: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the absolute value of this Decimal.
+     */
+    absoluteValue(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the absolute value of this Decimal.
+     */
+    abs(): Decimal;
+
+    /**
+     * Return
+     *   1    if the value of this Decimal is greater than the value of `y`,
+     *  -1    if the value of this Decimal is less than the value of `y`,
+     *   0    if they have the same value
+     */
+    comparedTo(y: Numeric): 1 | 0 | -1;
+
+    /**
+     * Return
+     *   1    if the value of this Decimal is greater than the value of `y`,
+     *  -1    if the value of this Decimal is less than the value of `y`,
+     *   0    if they have the same value
+     */
+    cmp(y: Numeric): 1 | 0 | -1;
+
+    /**
+     * Return the number of decimal places of the value of this Decimal.
+     */
+    decimalPlaces(): number;
+
+    /**
+     * Return the number of decimal places of the value of this Decimal.
+     */
+    dp(): number;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    dividedBy(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    div(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the integer part of dividing the value of this Decimal
+     * by the value of `y`, truncated to `precision` significant digits.
+     *
+     */
+    dividedToIntegerBy(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the integer part of dividing the value of this Decimal
+     * by the value of `y`, truncated to `precision` significant digits.
+     *
+     */
+    idiv(y: Numeric): Decimal;
+
+    /**
+     * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.
+     */
+    equals(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.
+     */
+    eq(y: Numeric): boolean;
+
+    /**
+     * Return the (base 10) exponent value of this Decimal (this.e is the base 10000000 exponent).
+     */
+    exponent(): number;
+
+    /**
+     * Return true if the value of this Decimal is greater than the value of `y`, otherwise return
+     * false.
+     */
+    greaterThan(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than the value of `y`, otherwise return
+     * false.
+     */
+    gt(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than or equal to the value of `y`,
+     * otherwise return false.
+     *
+     */
+    greaterThanOrEqualTo(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than or equal to the value of `y`,
+     * otherwise return false.
+     *
+     */
+    gte(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is an integer, otherwise return false.
+     *
+     */
+    isInteger(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is an integer, otherwise return false.
+     *
+     */
+    isint(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is negative, otherwise return false.
+     *
+     */
+    isNegative(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is negative, otherwise return false.
+     *
+     */
+    isneg(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is positive, otherwise return false.
+     *
+     */
+    isPositive(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is positive, otherwise return false.
+     *
+     */
+    ispos(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is 0, otherwise return false.
+     *
+     */
+    isZero(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than `y`, otherwise return false.
+     *
+     */
+    lessThan(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than `y`, otherwise return false.
+     *
+     */
+    lt(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.
+     *
+     */
+    lessThanOrEqualTo(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.
+     *
+     */
+    lte(y: Numeric): boolean;
+
+    /**
+     * Return the logarithm of the value of this Decimal to the specified base, truncated to
+     * `precision` significant digits.
+     *
+     * If no base is specified, return log[10](x).
+     *
+     * log[base](x) = ln(x) / ln(base)
+     *
+     * The maximum error of the result is 1 ulp (unit in the last place).
+     *
+     */
+    logarithm(base?: Numeric): Decimal;
+
+    /**
+     * Return the logarithm of the value of this Decimal to the specified base, truncated to
+     * `precision` significant digits.
+     *
+     * If no base is specified, return log[10](x).
+     *
+     * log[base](x) = ln(x) / ln(base)
+     *
+     * The maximum error of the result is 1 ulp (unit in the last place).
+     *
+     */
+    log(base?: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    minus(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    sub(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    modulo(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    mod(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural exponential of the value of this Decimal,
+     * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    naturalExponetial(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural exponential of the value of this Decimal,
+     * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    exp(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,
+     * truncated to `precision` significant digits.
+     *
+     */
+    naturalLogarithm(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,
+     * truncated to `precision` significant digits.
+     *
+     */
+    ln(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by
+     * -1.
+     *
+     */
+    negated(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by
+     * -1.
+     *
+     */
+    neg(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    plus(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    add(y: Numeric): Decimal;
+
+    /**
+     * Return the number of significant digits of the value of this Decimal.
+     *
+     * @param zeros {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.
+     */
+    precision(zeros: boolean | number): number;
+
+    /**
+     * Return the number of significant digits of the value of this Decimal.
+     *
+     * @param zeros {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.
+     */
+    sd(zeros: boolean | number): number;
+
+    /**
+     * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    squareRoot(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    sqrt(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    times(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    mul(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`
+     * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.
+     *
+     * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toDecimalPlaces(dp?: number, rm?: number): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`
+     * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.
+     *
+     * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    todp(dp?: number, rm?: number): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal in exponential notation rounded to
+     * `dp` fixed decimal places using rounding mode `rounding`.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toExponential(dp?: number, rm?: number): string;
+
+    /**
+     * Return a string representing the value of this Decimal in normal (fixed-point) notation to
+     * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is
+     * omitted.
+     *
+     * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+     * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+     * (-0).toFixed(3) is '0.000'.
+     * (-0.5).toFixed(0) is '-0'.
+     *
+     */
+    toFixed(dp?: number, rm?: number): string;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using
+     * rounding mode `rounding`.
+     *
+     */
+    toInteger(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using
+     * rounding mode `rounding`.
+     *
+     */
+    toint(): Decimal;
+
+    /**
+     * Return the value of this Decimal converted to a number primitive.
+     *
+     */
+    toNumber(): number;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,
+     * truncated to `precision` significant digits.
+     *
+     * For non-integer or very large exponents pow(x, y) is calculated using
+     *
+     *   x^y = exp(y*ln(x))
+     *
+     * The maximum error is 1 ulp (unit in last place).
+     *
+     * @param y {number|string|Decimal} The power to which to raise this Decimal.
+     *
+     */
+    toPower(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,
+     * truncated to `precision` significant digits.
+     *
+     * For non-integer or very large exponents pow(x, y) is calculated using
+     *
+     *   x^y = exp(y*ln(x))
+     *
+     * The maximum error is 1 ulp (unit in last place).
+     *
+     * @param y {number|string|Decimal} The power to which to raise this Decimal.
+     *
+     */
+    pow(y: Numeric): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal rounded to `sd` significant digits
+     * using rounding mode `rounding`.
+     *
+     * Return exponential notation if `sd` is less than the number of digits necessary to represent
+     * the integer part of the value in normal notation.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toPrecision(sd?: number, rm?: number): string;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`
+     * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if
+     * omitted.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toSignificantDigits(sd?: number, rm?: number): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`
+     * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if
+     * omitted.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    tosd(sd?: number, rm?: number): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    toString(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    valueOf(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    val(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    toJSON(): string;
+
+    /**
+     * Create and return a Decimal constructor with the same configuration properties as this Decimal
+     * constructor.
+     *
+     * @param config? DecimalConfig
+     */
+    static clone(config?: DecimalConfig): typeof Decimal;
+
+    /**
+     * Configure global settings for a Decimal constructor.
+     */
+    static config(config: DecimalConfig): Decimal;
+
+    /**
+     * Configure global settings for a Decimal constructor.
+     */
+    static set(config: DecimalConfig): Decimal;
+
+    // The maximum number of significant digits of the result of a calculation or base conversion.
+    // E.g. `Decimal.config({ precision: 20 });`
+    static precision: number;
+
+    // The rounding mode used by default by `toInteger`, `toDecimalPlaces`, `toExponential`,
+    // `toFixed`, `toPrecision` and `toSignificantDigits`.
+    //
+    // E.g.
+    // `Decimal.rounding = 4;`
+    // `Decimal.rounding = Decimal.ROUND_HALF_UP;`
+    static rounding: number;
+    static +ROUND_UP: number;
+    static +ROUND_DOWN: number;
+    static +ROUND_CEIL: number;
+    static +ROUND_FLOOR: number;
+    static +ROUND_HALF_UP: number;
+    static +ROUND_HALF_DOWN: number;
+    static +ROUND_HALF_EVEN: number;
+    static +ROUND_HALF_CEIL: number;
+    static +ROUND_HALF_FLOOR: number;
+
+    // The exponent value at and beneath which `toString` returns exponential notation.
+    // JavaScript numbers: -7
+    static toExpNeg: number; // 0 to -MAX_E
+
+    // The exponent value at and above which `toString` returns exponential notation.
+    // JavaScript numbers: 21
+    static toExpPos: number;// 0 to MAX_E
+
+    // The natural logarithm of 10.
+    static LN10: Decimal;
+  }
+
+  declare module.exports: typeof Decimal;
+}
diff --git a/definitions/npm/decimal.js-light_v2.4.x/flow_v0.201.x-/decimal.js-light_v2.4.x.js b/definitions/npm/decimal.js-light_v2.4.x/flow_v0.201.x-/decimal.js-light_v2.4.x.js
new file mode 100644
index 0000000000..f78570252a
--- /dev/null
+++ b/definitions/npm/decimal.js-light_v2.4.x/flow_v0.201.x-/decimal.js-light_v2.4.x.js
@@ -0,0 +1,573 @@
+declare module 'decimal.js-light' {
+  declare type Numeric = string | number | Decimal;
+
+  declare type DecimalConfig = $Shape<{
+   precision: number,
+   rounding: number,
+   toExpNeg: number,
+   toExpPos: number,
+   LN10: Numeric,
+   ...
+  }>;
+
+  declare class Decimal {
+    /**
+     * The Decimal constructor and exported function.
+     * Return a new Decimal instance.
+     *
+     * @param value {number|string|Decimal} A numeric value.
+     *
+     */
+    constructor(value: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the absolute value of this Decimal.
+     */
+    absoluteValue(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the absolute value of this Decimal.
+     */
+    abs(): Decimal;
+
+    /**
+     * Return
+     *   1    if the value of this Decimal is greater than the value of `y`,
+     *  -1    if the value of this Decimal is less than the value of `y`,
+     *   0    if they have the same value
+     */
+    comparedTo(y: Numeric): 1 | 0 | -1;
+
+    /**
+     * Return
+     *   1    if the value of this Decimal is greater than the value of `y`,
+     *  -1    if the value of this Decimal is less than the value of `y`,
+     *   0    if they have the same value
+     */
+    cmp(y: Numeric): 1 | 0 | -1;
+
+    /**
+     * Return the number of decimal places of the value of this Decimal.
+     */
+    decimalPlaces(): number;
+
+    /**
+     * Return the number of decimal places of the value of this Decimal.
+     */
+    dp(): number;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    dividedBy(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    div(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the integer part of dividing the value of this Decimal
+     * by the value of `y`, truncated to `precision` significant digits.
+     *
+     */
+    dividedToIntegerBy(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the integer part of dividing the value of this Decimal
+     * by the value of `y`, truncated to `precision` significant digits.
+     *
+     */
+    idiv(y: Numeric): Decimal;
+
+    /**
+     * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.
+     */
+    equals(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.
+     */
+    eq(y: Numeric): boolean;
+
+    /**
+     * Return the (base 10) exponent value of this Decimal (this.e is the base 10000000 exponent).
+     */
+    exponent(): number;
+
+    /**
+     * Return true if the value of this Decimal is greater than the value of `y`, otherwise return
+     * false.
+     */
+    greaterThan(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than the value of `y`, otherwise return
+     * false.
+     */
+    gt(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than or equal to the value of `y`,
+     * otherwise return false.
+     *
+     */
+    greaterThanOrEqualTo(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is greater than or equal to the value of `y`,
+     * otherwise return false.
+     *
+     */
+    gte(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is an integer, otherwise return false.
+     *
+     */
+    isInteger(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is an integer, otherwise return false.
+     *
+     */
+    isint(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is negative, otherwise return false.
+     *
+     */
+    isNegative(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is negative, otherwise return false.
+     *
+     */
+    isneg(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is positive, otherwise return false.
+     *
+     */
+    isPositive(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is positive, otherwise return false.
+     *
+     */
+    ispos(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is 0, otherwise return false.
+     *
+     */
+    isZero(): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than `y`, otherwise return false.
+     *
+     */
+    lessThan(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than `y`, otherwise return false.
+     *
+     */
+    lt(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.
+     *
+     */
+    lessThanOrEqualTo(y: Numeric): boolean;
+
+    /**
+     * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.
+     *
+     */
+    lte(y: Numeric): boolean;
+
+    /**
+     * Return the logarithm of the value of this Decimal to the specified base, truncated to
+     * `precision` significant digits.
+     *
+     * If no base is specified, return log[10](x).
+     *
+     * log[base](x) = ln(x) / ln(base)
+     *
+     * The maximum error of the result is 1 ulp (unit in the last place).
+     *
+     */
+    logarithm(base?: Numeric): Decimal;
+
+    /**
+     * Return the logarithm of the value of this Decimal to the specified base, truncated to
+     * `precision` significant digits.
+     *
+     * If no base is specified, return log[10](x).
+     *
+     * log[base](x) = ln(x) / ln(base)
+     *
+     * The maximum error of the result is 1 ulp (unit in the last place).
+     *
+     */
+    log(base?: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    minus(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    sub(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    modulo(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    mod(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural exponential of the value of this Decimal,
+     * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    naturalExponetial(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural exponential of the value of this Decimal,
+     * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    exp(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,
+     * truncated to `precision` significant digits.
+     *
+     */
+    naturalLogarithm(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,
+     * truncated to `precision` significant digits.
+     *
+     */
+    ln(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by
+     * -1.
+     *
+     */
+    negated(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by
+     * -1.
+     *
+     */
+    neg(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    plus(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    add(y: Numeric): Decimal;
+
+    /**
+     * Return the number of significant digits of the value of this Decimal.
+     *
+     * @param zeros {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.
+     */
+    precision(zeros: boolean | number): number;
+
+    /**
+     * Return the number of significant digits of the value of this Decimal.
+     *
+     * @param zeros {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.
+     */
+    sd(zeros: boolean | number): number;
+
+    /**
+     * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    squareRoot(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`
+     * significant digits.
+     *
+     */
+    sqrt(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    times(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to
+     * `precision` significant digits.
+     *
+     */
+    mul(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`
+     * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.
+     *
+     * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toDecimalPlaces(dp?: number, rm?: number): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`
+     * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.
+     *
+     * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    todp(dp?: number, rm?: number): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal in exponential notation rounded to
+     * `dp` fixed decimal places using rounding mode `rounding`.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toExponential(dp?: number, rm?: number): string;
+
+    /**
+     * Return a string representing the value of this Decimal in normal (fixed-point) notation to
+     * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is
+     * omitted.
+     *
+     * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.
+     *
+     * @param dp {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
+     * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
+     * (-0).toFixed(3) is '0.000'.
+     * (-0.5).toFixed(0) is '-0'.
+     *
+     */
+    toFixed(dp?: number, rm?: number): string;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using
+     * rounding mode `rounding`.
+     *
+     */
+    toInteger(): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using
+     * rounding mode `rounding`.
+     *
+     */
+    toint(): Decimal;
+
+    /**
+     * Return the value of this Decimal converted to a number primitive.
+     *
+     */
+    toNumber(): number;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,
+     * truncated to `precision` significant digits.
+     *
+     * For non-integer or very large exponents pow(x, y) is calculated using
+     *
+     *   x^y = exp(y*ln(x))
+     *
+     * The maximum error is 1 ulp (unit in last place).
+     *
+     * @param y {number|string|Decimal} The power to which to raise this Decimal.
+     *
+     */
+    toPower(y: Numeric): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,
+     * truncated to `precision` significant digits.
+     *
+     * For non-integer or very large exponents pow(x, y) is calculated using
+     *
+     *   x^y = exp(y*ln(x))
+     *
+     * The maximum error is 1 ulp (unit in last place).
+     *
+     * @param y {number|string|Decimal} The power to which to raise this Decimal.
+     *
+     */
+    pow(y: Numeric): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal rounded to `sd` significant digits
+     * using rounding mode `rounding`.
+     *
+     * Return exponential notation if `sd` is less than the number of digits necessary to represent
+     * the integer part of the value in normal notation.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toPrecision(sd?: number, rm?: number): string;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`
+     * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if
+     * omitted.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    toSignificantDigits(sd?: number, rm?: number): Decimal;
+
+    /**
+     * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`
+     * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if
+     * omitted.
+     *
+     * @param sd {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.
+     * @param rm {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     */
+    tosd(sd?: number, rm?: number): Decimal;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    toString(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    valueOf(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    val(): string;
+
+    /**
+     * Return a string representing the value of this Decimal.
+     *
+     * Return exponential notation if this Decimal has a positive exponent equal to or greater than
+     * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.
+     *
+     */
+    toJSON(): string;
+
+    /**
+     * Create and return a Decimal constructor with the same configuration properties as this Decimal
+     * constructor.
+     *
+     * @param config? DecimalConfig
+     */
+    static clone(config?: DecimalConfig): typeof Decimal;
+
+    /**
+     * Configure global settings for a Decimal constructor.
+     */
+    static config(config: DecimalConfig): Decimal;
+
+    /**
+     * Configure global settings for a Decimal constructor.
+     */
+    static set(config: DecimalConfig): Decimal;
+
+    // The maximum number of significant digits of the result of a calculation or base conversion.
+    // E.g. `Decimal.config({ precision: 20 });`
+    static precision: number;
+
+    // The rounding mode used by default by `toInteger`, `toDecimalPlaces`, `toExponential`,
+    // `toFixed`, `toPrecision` and `toSignificantDigits`.
+    //
+    // E.g.
+    // `Decimal.rounding = 4;`
+    // `Decimal.rounding = Decimal.ROUND_HALF_UP;`
+    static rounding: number;
+    static +ROUND_UP: number;
+    static +ROUND_DOWN: number;
+    static +ROUND_CEIL: number;
+    static +ROUND_FLOOR: number;
+    static +ROUND_HALF_UP: number;
+    static +ROUND_HALF_DOWN: number;
+    static +ROUND_HALF_EVEN: number;
+    static +ROUND_HALF_CEIL: number;
+    static +ROUND_HALF_FLOOR: number;
+
+    // The exponent value at and beneath which `toString` returns exponential notation.
+    // JavaScript numbers: -7
+    static toExpNeg: number; // 0 to -MAX_E
+
+    // The exponent value at and above which `toString` returns exponential notation.
+    // JavaScript numbers: 21
+    static toExpPos: number;// 0 to MAX_E
+
+    // The natural logarithm of 10.
+    static LN10: Decimal;
+  }
+
+  declare module.exports: typeof Decimal;
+}
diff --git a/definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-/deepmerge_v2.1.x.js b/definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-v0.200.x/deepmerge_v2.1.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-/deepmerge_v2.1.x.js
rename to definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-v0.200.x/deepmerge_v2.1.x.js
diff --git a/definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-/test_deepmerge_v2.1.x.js b/definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-v0.200.x/test_deepmerge_v2.1.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-/test_deepmerge_v2.1.x.js
rename to definitions/npm/deepmerge_v2.1.x/flow_v0.104.x-v0.200.x/test_deepmerge_v2.1.x.js
diff --git a/definitions/npm/deepmerge_v2.1.x/flow_v0.201.x-/deepmerge_v2.1.x.js b/definitions/npm/deepmerge_v2.1.x/flow_v0.201.x-/deepmerge_v2.1.x.js
new file mode 100644
index 0000000000..e252059db4
--- /dev/null
+++ b/definitions/npm/deepmerge_v2.1.x/flow_v0.201.x-/deepmerge_v2.1.x.js
@@ -0,0 +1,14 @@
+declare module 'deepmerge' {
+  declare type Options = {
+    clone?: boolean,
+    arrayMerge?: (destination: any[], source: any[], options?: Options) => Array<any>,
+    ...
+  }
+
+  declare module.exports: {
+    <A, B>(a: A, b: B, options?: Options): A & B,
+    all<T>(objects: Array<$Shape<T>>, options?: Options): T,
+    ...
+  };
+
+}
diff --git a/definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-/test_deepmerge_v3.x.x.js b/definitions/npm/deepmerge_v2.1.x/flow_v0.201.x-/test_deepmerge_v2.1.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-/test_deepmerge_v3.x.x.js
rename to definitions/npm/deepmerge_v2.1.x/flow_v0.201.x-/test_deepmerge_v2.1.x.js
diff --git a/definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-/deepmerge_v3.x.x.js b/definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-v0.200.x/deepmerge_v3.x.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-/deepmerge_v3.x.x.js
rename to definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-v0.200.x/deepmerge_v3.x.x.js
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-/test_deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-v0.200.x/test_deepmerge_v3.x.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-/test_deepmerge_v4.x.x.js
rename to definitions/npm/deepmerge_v3.x.x/flow_v0.104.x-v0.200.x/test_deepmerge_v3.x.x.js
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-/deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v3.x.x/flow_v0.201.x-/deepmerge_v3.x.x.js
similarity index 100%
rename from definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-/deepmerge_v4.x.x.js
rename to definitions/npm/deepmerge_v3.x.x/flow_v0.201.x-/deepmerge_v3.x.x.js
diff --git a/definitions/npm/deepmerge_v3.x.x/flow_v0.201.x-/test_deepmerge_v3.x.x.js b/definitions/npm/deepmerge_v3.x.x/flow_v0.201.x-/test_deepmerge_v3.x.x.js
new file mode 100644
index 0000000000..60447b190e
--- /dev/null
+++ b/definitions/npm/deepmerge_v3.x.x/flow_v0.201.x-/test_deepmerge_v3.x.x.js
@@ -0,0 +1,8 @@
+const deepmerge = require("deepmerge");
+
+const m1: { a: string, b: string, ... } = deepmerge({a: ''}, { b: '' })
+
+const m2: { a: string, b: string, ... } = deepmerge.all([ {a: ''}, { b: '' } ])
+
+// $FlowExpectedError[incompatible-type]
+const m3: { a: number, b: string, ... } = deepmerge({a: ''}, { b: '' })
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/deepmerge_v4.x.x.js
new file mode 100644
index 0000000000..9b636bb156
--- /dev/null
+++ b/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/deepmerge_v4.x.x.js
@@ -0,0 +1,15 @@
+declare module 'deepmerge' {
+  declare type Options = {
+    clone?: boolean,
+    arrayMerge?: (destination: any[], source: any[], options?: Options) => Array<any>,
+    isMergeableObject?: (value: { ... }) => boolean,
+    customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | void,
+    ...
+  }
+
+  declare module.exports: {
+    <A, B>(a: A, b: B, options?: Options): A & B,
+    all<T>(objects: Array<$Shape<T>>, options?: Options): T,
+    ...
+  };
+}
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/test_deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/test_deepmerge_v4.x.x.js
new file mode 100644
index 0000000000..60447b190e
--- /dev/null
+++ b/definitions/npm/deepmerge_v4.x.x/flow_v0.201.x-/test_deepmerge_v4.x.x.js
@@ -0,0 +1,8 @@
+const deepmerge = require("deepmerge");
+
+const m1: { a: string, b: string, ... } = deepmerge({a: ''}, { b: '' })
+
+const m2: { a: string, b: string, ... } = deepmerge.all([ {a: ''}, { b: '' } ])
+
+// $FlowExpectedError[incompatible-type]
+const m3: { a: number, b: string, ... } = deepmerge({a: ''}, { b: '' })
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/deepmerge_v4.x.x.js
new file mode 100644
index 0000000000..9b636bb156
--- /dev/null
+++ b/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/deepmerge_v4.x.x.js
@@ -0,0 +1,15 @@
+declare module 'deepmerge' {
+  declare type Options = {
+    clone?: boolean,
+    arrayMerge?: (destination: any[], source: any[], options?: Options) => Array<any>,
+    isMergeableObject?: (value: { ... }) => boolean,
+    customMerge?: (key: string, options?: Options) => ((x: any, y: any) => any) | void,
+    ...
+  }
+
+  declare module.exports: {
+    <A, B>(a: A, b: B, options?: Options): A & B,
+    all<T>(objects: Array<$Shape<T>>, options?: Options): T,
+    ...
+  };
+}
diff --git a/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/test_deepmerge_v4.x.x.js b/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/test_deepmerge_v4.x.x.js
new file mode 100644
index 0000000000..60447b190e
--- /dev/null
+++ b/definitions/npm/deepmerge_v4.x.x/flow_v0.83.x-v0.200.x/test_deepmerge_v4.x.x.js
@@ -0,0 +1,8 @@
+const deepmerge = require("deepmerge");
+
+const m1: { a: string, b: string, ... } = deepmerge({a: ''}, { b: '' })
+
+const m2: { a: string, b: string, ... } = deepmerge.all([ {a: ''}, { b: '' } ])
+
+// $FlowExpectedError[incompatible-type]
+const m3: { a: number, b: string, ... } = deepmerge({a: ''}, { b: '' })
diff --git a/definitions/npm/dompurify_v1.x.x/flow_v0.104.x-/dompurify_v1.x.x.js b/definitions/npm/dompurify_v1.x.x/flow_v0.104.x-v0.200.x/dompurify_v1.x.x.js
similarity index 100%
rename from definitions/npm/dompurify_v1.x.x/flow_v0.104.x-/dompurify_v1.x.x.js
rename to definitions/npm/dompurify_v1.x.x/flow_v0.104.x-v0.200.x/dompurify_v1.x.x.js
diff --git a/definitions/npm/dompurify_v1.x.x/flow_v0.201.x-/dompurify_v1.x.x.js b/definitions/npm/dompurify_v1.x.x/flow_v0.201.x-/dompurify_v1.x.x.js
new file mode 100644
index 0000000000..4d7bf40f72
--- /dev/null
+++ b/definitions/npm/dompurify_v1.x.x/flow_v0.201.x-/dompurify_v1.x.x.js
@@ -0,0 +1,740 @@
+type dompurify$htmlTags =
+  | 'a'
+  | 'abbr'
+  | 'acronym'
+  | 'address'
+  | 'area'
+  | 'article'
+  | 'aside'
+  | 'audio'
+  | 'b'
+  | 'bdi'
+  | 'bdo'
+  | 'big'
+  | 'blink'
+  | 'blockquote'
+  | 'body'
+  | 'br'
+  | 'button'
+  | 'canvas'
+  | 'caption'
+  | 'center'
+  | 'cite'
+  | 'code'
+  | 'col'
+  | 'colgroup'
+  | 'content'
+  | 'data'
+  | 'datalist'
+  | 'dd'
+  | 'decorator'
+  | 'del'
+  | 'details'
+  | 'dfn'
+  | 'dir'
+  | 'div'
+  | 'dl'
+  | 'dt'
+  | 'element'
+  | 'em'
+  | 'fieldset'
+  | 'figcaption'
+  | 'figure'
+  | 'font'
+  | 'footer'
+  | 'form'
+  | 'h1'
+  | 'h2'
+  | 'h3'
+  | 'h4'
+  | 'h5'
+  | 'h6'
+  | 'head'
+  | 'header'
+  | 'hgroup'
+  | 'hr'
+  | 'html'
+  | 'i'
+  | 'img'
+  | 'input'
+  | 'ins'
+  | 'kbd'
+  | 'label'
+  | 'legend'
+  | 'li'
+  | 'main'
+  | 'map'
+  | 'mark'
+  | 'marquee'
+  | 'menu'
+  | 'menuitem'
+  | 'meter'
+  | 'nav'
+  | 'nobr'
+  | 'ol'
+  | 'optgroup'
+  | 'option'
+  | 'output'
+  | 'p'
+  | 'pre'
+  | 'progress'
+  | 'q'
+  | 'rp'
+  | 'rt'
+  | 'ruby'
+  | 's'
+  | 'samp'
+  | 'section'
+  | 'select'
+  | 'shadow'
+  | 'small'
+  | 'source'
+  | 'spacer'
+  | 'span'
+  | 'strike'
+  | 'strong'
+  | 'style'
+  | 'sub'
+  | 'summary'
+  | 'sup'
+  | 'table'
+  | 'tbody'
+  | 'td'
+  | 'template'
+  | 'textarea'
+  | 'tfoot'
+  | 'th'
+  | 'thead'
+  | 'time'
+  | 'tr'
+  | 'track'
+  | 'tt'
+  | 'u'
+  | 'ul'
+  | 'var'
+  | 'video'
+  | 'wbr'
+  | '#text';
+
+type dompurify$htmlAttrs =
+  | 'accept'
+  | 'action'
+  | 'align'
+  | 'alt'
+  | 'autocomplete'
+  | 'background'
+  | 'bgcolor'
+  | 'border'
+  | 'cellpadding'
+  | 'cellspacing'
+  | 'checked'
+  | 'cite'
+  | 'class'
+  | 'clear'
+  | 'color'
+  | 'cols'
+  | 'colspan'
+  | 'coords'
+  | 'crossorigin'
+  | 'datetime'
+  | 'default'
+  | 'dir'
+  | 'disabled'
+  | 'download'
+  | 'enctype'
+  | 'face'
+  | 'for'
+  | 'headers'
+  | 'height'
+  | 'hidden'
+  | 'high'
+  | 'href'
+  | 'hreflang'
+  | 'id'
+  | 'integrity'
+  | 'ismap'
+  | 'label'
+  | 'lang'
+  | 'list'
+  | 'loop'
+  | 'low'
+  | 'max'
+  | 'maxlength'
+  | 'media'
+  | 'method'
+  | 'min'
+  | 'multiple'
+  | 'name'
+  | 'noshade'
+  | 'novalidate'
+  | 'nowrap'
+  | 'open'
+  | 'optimum'
+  | 'pattern'
+  | 'placeholder'
+  | 'poster'
+  | 'preload'
+  | 'pubdate'
+  | 'radiogroup'
+  | 'readonly'
+  | 'rel'
+  | 'required'
+  | 'rev'
+  | 'reversed'
+  | 'role'
+  | 'rows'
+  | 'rowspan'
+  | 'spellcheck'
+  | 'scope'
+  | 'selected'
+  | 'shape'
+  | 'size'
+  | 'sizes'
+  | 'span'
+  | 'srclang'
+  | 'start'
+  | 'src'
+  | 'srcset'
+  | 'step'
+  | 'style'
+  | 'summary'
+  | 'tabindex'
+  | 'title'
+  | 'type'
+  | 'usemap'
+  | 'valign'
+  | 'value'
+  | 'width'
+  | 'xmlns';
+
+type dompurify$svgTags =
+  | 'svg'
+  | 'a'
+  | 'altglyph'
+  | 'altglyphdef'
+  | 'altglyphitem'
+  | 'animatecolor'
+  | 'animatemotion'
+  | 'animatetransform'
+  | 'audio'
+  | 'canvas'
+  | 'circle'
+  | 'clippath'
+  | 'defs'
+  | 'desc'
+  | 'ellipse'
+  | 'filter'
+  | 'font'
+  | 'g'
+  | 'glyph'
+  | 'glyphref'
+  | 'hkern'
+  | 'image'
+  | 'line'
+  | 'lineargradient'
+  | 'marker'
+  | 'mask'
+  | 'metadata'
+  | 'mpath'
+  | 'path'
+  | 'pattern'
+  | 'polygon'
+  | 'polyline'
+  | 'radialgradient'
+  | 'rect'
+  | 'stop'
+  | 'style'
+  | 'switch'
+  | 'symbol'
+  | 'text'
+  | 'textpath'
+  | 'title'
+  | 'tref'
+  | 'tspan'
+  | 'video'
+  | 'view'
+  | 'vkern';
+
+type dompurify$svgAttrs =
+  | 'accent-height'
+  | 'accumulate'
+  | 'additivive'
+  | 'alignment-baseline'
+  | 'ascent'
+  | 'attributename'
+  | 'attributetype'
+  | 'azimuth'
+  | 'basefrequency'
+  | 'baseline-shift'
+  | 'begin'
+  | 'bias'
+  | 'by'
+  | 'class'
+  | 'clip'
+  | 'clip-path'
+  | 'clip-rule'
+  | 'color'
+  | 'color-interpolation'
+  | 'color-interpolation-filters'
+  | 'color-profile'
+  | 'color-rendering'
+  | 'cx'
+  | 'cy'
+  | 'd'
+  | 'dx'
+  | 'dy'
+  | 'diffuseconstant'
+  | 'direction'
+  | 'display'
+  | 'divisor'
+  | 'dur'
+  | 'edgemode'
+  | 'elevation'
+  | 'end'
+  | 'fill'
+  | 'fill-opacity'
+  | 'fill-rule'
+  | 'filter'
+  | 'flood-color'
+  | 'flood-opacity'
+  | 'font-family'
+  | 'font-size'
+  | 'font-size-adjust'
+  | 'font-stretch'
+  | 'font-style'
+  | 'font-variant'
+  | 'font-weight'
+  | 'fx'
+  | 'fy'
+  | 'g1'
+  | 'g2'
+  | 'glyph-name'
+  | 'glyphref'
+  | 'gradientunits'
+  | 'gradienttransform'
+  | 'height'
+  | 'href'
+  | 'id'
+  | 'image-rendering'
+  | 'in'
+  | 'in2'
+  | 'k'
+  | 'k1'
+  | 'k2'
+  | 'k3'
+  | 'k4'
+  | 'kerning'
+  | 'keypoints'
+  | 'keysplines'
+  | 'keytimes'
+  | 'lang'
+  | 'lengthadjust'
+  | 'letter-spacing'
+  | 'kernelmatrix'
+  | 'kernelunitlength'
+  | 'lighting-color'
+  | 'local'
+  | 'marker-end'
+  | 'marker-mid'
+  | 'marker-start'
+  | 'markerheight'
+  | 'markerunits'
+  | 'markerwidth'
+  | 'maskcontentunits'
+  | 'maskunits'
+  | 'max'
+  | 'mask'
+  | 'media'
+  | 'method'
+  | 'mode'
+  | 'min'
+  | 'name'
+  | 'numoctaves'
+  | 'offset'
+  | 'operator'
+  | 'opacity'
+  | 'order'
+  | 'orient'
+  | 'orientation'
+  | 'origin'
+  | 'overflow'
+  | 'paint-order'
+  | 'path'
+  | 'pathlength'
+  | 'patterncontentunits'
+  | 'patterntransform'
+  | 'patternunits'
+  | 'points'
+  | 'preservealpha'
+  | 'preserveaspectratio'
+  | 'r'
+  | 'rx'
+  | 'ry'
+  | 'radius'
+  | 'refx'
+  | 'refy'
+  | 'repeatcount'
+  | 'repeatdur'
+  | 'restart'
+  | 'result'
+  | 'rotate'
+  | 'scale'
+  | 'seed'
+  | 'shape-rendering'
+  | 'specularconstant'
+  | 'specularexponent'
+  | 'spreadmethod'
+  | 'stddeviation'
+  | 'stitchtiles'
+  | 'stop-color'
+  | 'stop-opacity'
+  | 'stroke-dasharray'
+  | 'stroke-dashoffset'
+  | 'stroke-linecap'
+  | 'stroke-linejoin'
+  | 'stroke-miterlimit'
+  | 'stroke-opacity'
+  | 'stroke'
+  | 'stroke-width'
+  | 'style'
+  | 'surfacescale'
+  | 'tabindex'
+  | 'targetx'
+  | 'targety'
+  | 'transform'
+  | 'text-anchor'
+  | 'text-decoration'
+  | 'text-rendering'
+  | 'textlength'
+  | 'type'
+  | 'u1'
+  | 'u2'
+  | 'unicode'
+  | 'values'
+  | 'viewbox'
+  | 'visibility'
+  | 'vert-adv-y'
+  | 'vert-origin-x'
+  | 'vert-origin-y'
+  | 'width'
+  | 'word-spacing'
+  | 'wrap'
+  | 'writing-mode'
+  | 'xchannelselector'
+  | 'ychannelselector'
+  | 'x'
+  | 'x1'
+  | 'x2'
+  | 'xmlns'
+  | 'y'
+  | 'y1'
+  | 'y2'
+  | 'z'
+  | 'zoomandpan';
+
+type dompurify$svgFilters =
+  | 'feBlend'
+  | 'feColorMatrix'
+  | 'feComponentTransfer'
+  | 'feComposite'
+  | 'feConvolveMatrix'
+  | 'feDiffuseLighting'
+  | 'feDisplacementMap'
+  | 'feDistantLight'
+  | 'feFlood'
+  | 'feFuncA'
+  | 'feFuncB'
+  | 'feFuncG'
+  | 'feFuncR'
+  | 'feGaussianBlur'
+  | 'feMerge'
+  | 'feMergeNode'
+  | 'feMorphology'
+  | 'feOffset'
+  | 'fePointLight'
+  | 'feSpecularLighting'
+  | 'feSpotLight'
+  | 'feTile'
+  | 'feTurbulence';
+
+type dompurify$mathMlTags =
+  | 'math'
+  | 'menclose'
+  | 'merror'
+  | 'mfenced'
+  | 'mfrac'
+  | 'mglyph'
+  | 'mi'
+  | 'mlabeledtr'
+  | 'mmuliscripts'
+  | 'mn'
+  | 'mo'
+  | 'mover'
+  | 'mpadded'
+  | 'mphantom'
+  | 'mroot'
+  | 'mrow'
+  | 'ms'
+  | 'mpspace'
+  | 'msqrt'
+  | 'mystyle'
+  | 'msub'
+  | 'msup'
+  | 'msubsup'
+  | 'mtable'
+  | 'mtd'
+  | 'mtext'
+  | 'mtr'
+  | 'munder'
+  | 'munderover';
+
+type dompurify$mathMlAttrs =
+  | 'accent'
+  | 'accentunder'
+  | 'align'
+  | 'bevelled'
+  | 'close'
+  | 'columnsalign'
+  | 'columnlines'
+  | 'columnspan'
+  | 'denomalign'
+  | 'depth'
+  | 'dir'
+  | 'display'
+  | 'displaystyle'
+  | 'fence'
+  | 'frame'
+  | 'height'
+  | 'href'
+  | 'id'
+  | 'largeop'
+  | 'length'
+  | 'linethickness'
+  | 'lspace'
+  | 'lquote'
+  | 'mathbackground'
+  | 'mathcolor'
+  | 'mathsize'
+  | 'mathvariant'
+  | 'maxsize'
+  | 'minsize'
+  | 'movablelimits'
+  | 'notation'
+  | 'numalign'
+  | 'open'
+  | 'rowalign'
+  | 'rowlines'
+  | 'rowspacing'
+  | 'rowspan'
+  | 'rspace'
+  | 'rquote'
+  | 'scriptlevel'
+  | 'scriptminsize'
+  | 'scriptsizemultiplier'
+  | 'selection'
+  | 'separator'
+  | 'separators'
+  | 'stretchy'
+  | 'subscriptshift'
+  | 'supscriptshift'
+  | 'symmetric'
+  | 'voffset'
+  | 'width'
+  | 'xmlns';
+
+type dompurify$tags = dompurify$htmlTags | dompurify$svgTags | dompurify$svgFilters | dompurify$mathMlTags;
+
+type dompurify$attr = dompurify$htmlAttrs | dompurify$svgAttrs | dompurify$mathMlAttrs;
+
+type dompurify$configBase = {|
+  /**
+   * make output safe for usage in jQuery's $()/html() method (default is false)
+   */
+  SAFE_FOR_JQUERY: boolean,
+  /**
+   * strip {{ ... }} and <% ... %> to make output safe for template systems
+   */
+  SAFE_FOR_TEMPLATES: boolean,
+  /**
+   * allow only tags
+   */
+  ALLOWED_TAGS: Array<dompurify$tags>,
+  /**
+   * allow only attrs
+   */
+  ALLOWED_ATTR: Array<dompurify$attr>,
+  /**
+   * allow all safe elements of different types
+   */
+  USE_PROFILES: $Shape<{
+    html: boolean,
+    svg: boolean,
+    svgFilters: boolean,
+    mathMl: boolean,
+    ...
+  }>,
+  /**
+   * leave all as it is but forbid specified tags
+   */
+  FORBID_TAGS: Array<dompurify$tags>,
+  /**
+   * leave all as it is but forbid specified attrs
+   */
+  FORBID_ATTR: Array<dompurify$attr>,
+  /**
+   * extend the existing array of allowed tags
+   */
+  ADD_TAGS: Array<string>,
+  /**
+   * extend the existing array of attributes
+   */
+  ADD_ATTR: Array<string>,
+  /**
+   * prohibit HTML5 data attributes (default is true)
+   */
+  ALLOW_DATA_ATTR: boolean,
+  /**
+   * allow external protocol handlers in URL attributes (default is false)
+   * by default only http, https, ftp, ftps, tel, mailto, callto, cid and xmpp are allowed.
+   */
+  ALLOW_UNKNOWN_PROTOCOLS: boolean,
+  /**
+   * allow specific protocols handlers in URL attributes (default is false)
+   * by default only http, https, ftp, ftps, tel, mailto, callto, cid and xmpp are allowed.
+   * Default RegExp: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
+   */
+  ALLOWED_URI_REGEXP: RegExp,
+  /**
+   * return a DOM HTMLBodyElement instead of an HTML string (default is false)
+   */
+  RETURN_DOM: boolean,
+  /**
+   * return a DOM DocumentFragment instead of an HTML string (default is false)
+   */
+  RETURN_DOM_FRAGMENT: boolean,
+  /**
+   * Import DocumentFragment into the current document (default is false).
+   * RETURN_DOM_IMPORT must be set if you would like to append the returned node to the current document
+   */
+  RETURN_DOM_IMPORT: boolean,
+  /**
+   * return entire document as string including <html> tags (default is false)
+   */
+  WHOLE_DOCUMENT: boolean,
+  /**
+   * disable DOM Clobbering protection on output (default is true, handle with care!)
+   */
+  SANITIZE_DOM: boolean,
+  /**
+   * discard an element's content when the element is removed (default is true)
+   */
+  KEEP_CONTENT: boolean,
+  /**
+   * glue elements like style, script or others to document.body and prevent unintuitive browser behavior
+   * in several edge-cases (default is false)
+   */
+  FORCE_BODY: boolean,
+  /**
+   * use the IN_PLACE mode to sanitize a node "in place", which is much faster depending on how you use DOMpurify
+   */
+  IN_PLACE: boolean,
+|};
+
+type dompurify$hookType =
+  | 'beforeSanitizeElements'
+  | 'uponSanitizeElement'
+  | 'afterSanitizeElements'
+  | 'beforeSanitizeAttributes'
+  | 'uponSanitizeAttribute'
+  | 'afterSanitizeAttributes'
+  | 'beforeSanitizeShadowDOM'
+  | 'uponSanitizeShadowNode'
+  | 'afterSanitizeShadowDOM';
+
+type dompurify$hookEvent = {
+  +tagName: ?dompurify$tags,
+  +allowedTags: ?{ [dompurify$tags]: boolean, ... },
+  +allowedAttributes: ?{ [dompurify$attr]: boolean, ... },
+  +attrName: ?dompurify$attr,
+  +attrValue: ?string,
+  // This is intended to be writable
+  keepAttr: ?boolean,
+  ...
+};
+
+declare type dompurify$config = $Shape<dompurify$configBase>;
+
+type dompurify$hook = (node: Node, data: ?dompurify$hookEvent, config?: dompurify$config) => void;
+
+interface dompurify$sanitizer {
+  (dirty: string, config: $Shape<$Diff<dompurify$configBase, {
+    RETURN_DOM: boolean,
+    RETURN_DOM_FRAGMENT: boolean,
+    ...
+  }>>): string,
+  (dirty: string, config: dompurify$config & {
+    RETURN_DOM: false,
+    RETURN_DOM_FRAGMENT: false,
+    ...
+  }): string,
+  (dirty: string, config: dompurify$config & {
+    RETURN_DOM: true,
+    RETURN_DOM_FRAGMENT?: void | false,
+    ...
+  }): HTMLBodyElement,
+  (dirty: string, config: dompurify$config & {
+    RETURN_DOM?: void | false,
+    RETURN_DOM_FRAGMENT: true,
+    ...
+  }): DocumentFragment,
+  (dirty: string): string,
+}
+
+type dompurify$instance = {|
+  +version: string,
+  +removed: Array<{ element: Node, ... } | {
+    attribute: ?Attr,
+    from: Node,
+    ...
+  }>,
+  +isSupported: boolean,
+  sanitize: dompurify$sanitizer,
+  setConfig: (config: dompurify$config) => void,
+  clearConfig: () => void,
+  isValidAttribute: (tag: string, attr: string, value: string) => boolean,
+  addHook: (dompurify$hookType, dompurify$hook) => void,
+  removeHook: (dompurify$hookType) => void,
+  removeHooks: (dompurify$hookType) => void,
+  removeAllHooks: () => void,
+|};
+
+type dompurify$creator = (window?: any) => dompurify$instance;
+
+declare module 'dompurify' {
+  declare module.exports: dompurify$creator;
+}
+declare module 'dompurify/dist/purify.cjs' {
+  declare module.exports: dompurify$creator;
+}
+declare module 'dompurify/dist/purify.es' {
+  declare module.exports: dompurify$creator;
+}
+declare module 'dompurify/dist/purify' {
+  declare module.exports: dompurify$creator;
+}
+declare module 'dompurify/dist/purify.min' {
+  declare module.exports: dompurify$creator;
+}
+
+declare module 'dompurify/dist/purify.cjs.js' {
+  declare module.exports: $Exports<'dompurify/dist/purify.cjs'>;
+}
+declare module 'dompurify/dist/purify.es.js' {
+  declare module.exports: $Exports<'dompurify/dist/purify.es'>;
+}
+declare module 'dompurify/dist/purify.js' {
+  declare module.exports: $Exports<'dompurify/dist/purify'>;
+}
+declare module 'dompurify/dist/purify.min.js' {
+  declare module.exports: $Exports<'dompurify/dist/purify.min'>;
+}
diff --git a/definitions/npm/dotenv_v8.x.x/flow_v0.53.x-/dotenv_v8.x.x.js b/definitions/npm/dotenv_v8.x.x/flow_v0.201.x-/dotenv_v8.x.x.js
similarity index 100%
rename from definitions/npm/dotenv_v8.x.x/flow_v0.53.x-/dotenv_v8.x.x.js
rename to definitions/npm/dotenv_v8.x.x/flow_v0.201.x-/dotenv_v8.x.x.js
diff --git a/definitions/npm/dotenv_v8.x.x/flow_v0.53.x-v0.200.x/dotenv_v8.x.x.js b/definitions/npm/dotenv_v8.x.x/flow_v0.53.x-v0.200.x/dotenv_v8.x.x.js
new file mode 100644
index 0000000000..bb0dd08a6e
--- /dev/null
+++ b/definitions/npm/dotenv_v8.x.x/flow_v0.53.x-v0.200.x/dotenv_v8.x.x.js
@@ -0,0 +1,23 @@
+// @flow
+
+declare module 'dotenv' {
+  declare type ParseResult = {| [key: string]: string |};
+  declare type ConfigResult = {| parsed: ParseResult |} | {| error: Error |};
+  declare function config(
+    options?: $Shape<{| path: string, encoding: string, debug: boolean |}>
+  ): ConfigResult;
+
+  declare function parse(
+    buffer: Buffer | string,
+    options?: $Shape<{| debug: boolean |}>
+  ): ParseResult;
+
+  declare module.exports: {|
+    config: typeof config,
+    parse: typeof parse,
+  |};
+}
+
+// eslint-disable-next-line no-empty
+declare module 'dotenv/config' {
+}
diff --git a/definitions/npm/formik_v0.11.x/flow_v0.104.x-/formik_v0.11.x.js b/definitions/npm/formik_v0.11.x/flow_v0.104.x-v0.200.x/formik_v0.11.x.js
similarity index 100%
rename from definitions/npm/formik_v0.11.x/flow_v0.104.x-/formik_v0.11.x.js
rename to definitions/npm/formik_v0.11.x/flow_v0.104.x-v0.200.x/formik_v0.11.x.js
diff --git a/definitions/npm/formik_v0.11.x/flow_v0.104.x-/test_formik.js b/definitions/npm/formik_v0.11.x/flow_v0.104.x-v0.200.x/test_formik.js
similarity index 100%
rename from definitions/npm/formik_v0.11.x/flow_v0.104.x-/test_formik.js
rename to definitions/npm/formik_v0.11.x/flow_v0.104.x-v0.200.x/test_formik.js
diff --git a/definitions/npm/formik_v0.11.x/flow_v0.201.x-/formik_v0.11.x.js b/definitions/npm/formik_v0.11.x/flow_v0.201.x-/formik_v0.11.x.js
new file mode 100644
index 0000000000..bac9b51f97
--- /dev/null
+++ b/definitions/npm/formik_v0.11.x/flow_v0.201.x-/formik_v0.11.x.js
@@ -0,0 +1,276 @@
+declare module "formik" {
+  declare export type FormikErrors<Values> = { [field: $Keys<Values>]: ?string, ... };
+
+  declare export type FormikTouched<Values> = { [field: $Keys<Values>]: boolean, ... };
+
+  /**
+   * Using interface here because interfaces support overloaded method signatures
+   * https://github.com/facebook/flow/issues/1556#issuecomment-200051475
+   */
+  declare export interface 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<Values>): void;
+    /** Manually set isSubmitting */
+    setSubmitting(isSubmitting: boolean): void;
+    /** Manually set touched object */
+    setTouched(touched: FormikTouched<Values>): void;
+    /** Manually set values object  */
+    setValues(values: Values): void;
+    /** Set value of form field directly */
+    setFieldValue<FieldName: $Keys<Values>>(
+      field: FieldName,
+      // I don't understand why we have to wrap this with $Call. I feel
+      // like we should just be able to do
+      // value: $ElementType<Values, FieldName>. But apparently this
+      // doesn't work.
+      value: $Call<() => $ElementType<Values, FieldName>>,
+      shouldValidate?: boolean
+    ): 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,
+      shouldValidate?: boolean
+    ): void;
+    /** Validate form values */
+    validateForm(values?: any): void;
+    /** Reset form */
+    resetForm(nextValues?: any): void;
+    /** Submit the form imperatively */
+    submitForm(): void;
+    /** Set Formik state, careful! */
+    setFormikState(
+      f: (
+        prevState: $ReadOnly<FormikState<Values>>,
+        props: any
+      ) => $Shape<FormikState<Values>>,
+      callback?: () => any
+    ): 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<Values: Object> = FormikSharedConfig & {
+   /**
+    * Initial values of the form
+    */
+   initialValues?: Values,
+   /**
+    * Reset handler
+    */
+   onReset?: (values: Values, formikActions: FormikActions<Values>) => void,
+   /**
+    * Submission handler
+    */
+   onSubmit: (values: Values, formikActions: FormikActions<Values>) => any,
+   /**
+    * Form component to render
+    */
+   component?: React$ComponentType<FormikProps<Values>> | React$Node,
+   /**
+    * Render prop (works like React router's <Route render={props =>} />)
+    */
+   render?: (props: FormikProps<Values>) => 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: Values) => void | FormikErrors<Values> | Promise<any>,
+   /**
+    * React children or child render callback
+    */
+   children?: ((props: FormikProps<Values>) => 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<Values>,
+   /** map of field names to whether the field has been touched */
+   touched: FormikTouched<Values>,
+   /** whether the form is currently submitting */
+   isSubmitting: boolean,
+   /** Top level status state, in case you need it */
+   status?: any,
+   /** Number of times user tried to submit the form */
+   submitCount: number,
+   ...
+  };
+
+  /**
+   * 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 */
+   handleSubmit: (e: SyntheticEvent<any>) => any,
+   /** Classic React change handler, keyed by input name */
+   handleChange: (e: SyntheticEvent<any>) => any,
+   /** Classic React blur handler */
+   handleBlur: (e: any) => void,
+   /** Reset form event handler  */
+   handleReset: () => void,
+   ...
+  };
+
+  declare export type FormikProps<Values> = FormikState<Values> &
+    FormikActions<Values> &
+    FormikHandlers &
+    FormikComputedProps<Values>;
+
+  declare export class Formik<
+    Values: Object,
+    Props: FormikConfig<Values>,
+
+  > 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>,
+   ...
+  };
+
+  /*
+  import * as React from 'react';
+
+  type OwnProps = {};
+  type Props = OwnProps & FormikProps;
+  class MyFormikHoc extends React.Component<Props> {
+     render() {
+        const { setFieldValue, status, errors, dirty } = this.props;
+     }
+  }
+
+  const enhancer = withFormik({});
+
+  // TODO - extract FormikProps from enhancer
+  type FormikProps = $Call<enhancer, OwnProps>
+
+  export default enhancer(MyFormikHoc);
+   */
+
+  declare export var Field: React$StatelessFunctionalComponent<any>;
+
+  declare export var Form: React$StatelessFunctionalComponent<any>;
+
+  /**
+   * Formik actions + { props }
+   */
+  declare export type FormikBag<P, V> = { props: P, ... } & FormikActions<V>;
+
+  /**
+   * withFormik() configuration options. Backwards compatible.
+   */
+  declare export type WithFormikConfig<
+    Props,
+    Values,
+  > = FormikSharedConfig & {
+   /**
+    * Set the display name of the component. Useful for React DevTools.
+    */
+   displayName?: string,
+   /**
+    * Submission handler
+    */
+   handleSubmit: (values: Values, formikBag: FormikBag<Props, Values>) => void,
+   /**
+    * Map props to the form values
+    */
+   mapPropsToValues?: (props: Props) => Values,
+   /**
+    * A Yup Schema or a function that returns a Yup schema
+    */
+   validationSchema?: any | ((props: Props) => 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: Values) => void | FormikErrors<Values> | Promise<any>,
+   ...
+  }
+
+  declare type TypeOrVoid = <V>(V) => (V | void)
+
+  declare export function withFormik<
+    Props,
+    Values,
+  >(WithFormikConfig<Props, Values>): (
+    Component: React$ComponentType<Props>
+  ) => React$ComponentType<$Diff<Props, $ObjMap<FormikProps<Values>, TypeOrVoid>>>;
+}
diff --git a/definitions/npm/formik_v0.11.x/flow_v0.201.x-/test_formik.js b/definitions/npm/formik_v0.11.x/flow_v0.201.x-/test_formik.js
new file mode 100644
index 0000000000..196bbd0966
--- /dev/null
+++ b/definitions/npm/formik_v0.11.x/flow_v0.201.x-/test_formik.js
@@ -0,0 +1,379 @@
+// @flow
+
+import * as React from "react";
+import { Formik, Form, Field } from "formik";
+import type { FieldProps, FormikActions, FormikProps } from "formik";
+import { describe, it } from "flow-typed-test";
+
+const i18n = { loadNamespaces: () => {} };
+
+type Values = {
+  text: string,
+  ...
+};
+
+describe("formik", () => {
+  describe("<Formik />", () => {
+    it("passes when used properly", () => {
+      <Formik
+        initialValues={{ text: "text" }}
+        validate={(values) => {
+          const errors = {};
+          if (!values.text) {
+            errors.text = "Text Required";
+          }
+          return errors;
+        }}
+        onSubmit={(
+          values,
+          { setSubmitting, setFieldError }
+        ) => {
+          setFieldError("text", "Text is Required!");
+          setSubmitting(false);
+        }}
+        render={({
+          values,
+          errors,
+          touched,
+          handleChange,
+          handleBlur,
+          handleSubmit,
+          isSubmitting
+        }) => {
+          return (
+            <form onSubmit={handleSubmit}>
+              <input
+                type="text"
+                name="text"
+                onChange={(e: SyntheticInputEvent<>) => {
+                  handleChange(e);
+                }}
+                onBlur={handleBlur}
+                value={values.text}
+              />
+              {touched.text && errors.text && <div>{errors.text}</div>}
+              <button type="submit" disabled={isSubmitting}>
+                Submit
+              </button>
+            </form>
+          );
+        }}
+      />;
+    });
+
+    it("raises error when trying to access values not in Values", () => {
+      <Formik
+        initialValues={{ text: "text" }}
+        validate={(values) => {
+          const errors = {};
+          if (!values.text) {
+            errors.text = "Text Required";
+          }
+          return errors;
+        }}
+        onSubmit={(values) => {}}
+        render={({
+          // $FlowExpectedError[incompatible-use]
+          values,
+          // $FlowExpectedError[incompatible-use]
+          errors,
+          // $FlowExpectedError[incompatible-use]
+          touched,
+          handleChange,
+          handleBlur,
+          handleSubmit,
+          isSubmitting
+        }) => {
+          return (
+            <form onSubmit={handleSubmit}>
+              <input
+                type="text"
+                name="text"
+                onChange={handleChange}
+                onBlur={handleBlur}
+                value={values.email}
+              />
+              {touched.email && errors.email && <div>{errors.email}</div>}
+              <button type="submit" disabled={isSubmitting}>
+                Submit
+              </button>
+            </form>
+          );
+        }}
+      />;
+    });
+
+    it("raises error when trying to update fields with values of the wrong type", () => {
+      <Formik
+        initialValues={{ text: "text" }}
+        onSubmit={(values) => {}}
+        render={({
+          values,
+          // $FlowExpectedError[incompatible-use]
+          setFieldValue,
+        }) => {
+          return (
+            <form>
+              <button onClick={() => {
+                setFieldValue("text", "new value")
+                setFieldValue("text", 3)
+              }}>
+                Submit
+              </button>
+            </form>
+          );
+        }}
+      />;
+    });
+  });
+
+  it("respects the user specifying more specific initialValues", () => {
+      type FormValues = {
+        requestState: "loading" | "ready",
+        ...
+      }
+      const initialValues: FormValues = {requestState: "loading"}
+      const rendered = <Formik
+        initialValues={initialValues}
+        onSubmit={values => {}}
+        render={({
+          // $FlowExpectedError[incompatible-use]
+          setFieldValue,
+        }) => {
+          return (
+            <form>
+              <button onClick={() => {
+                setFieldValue("requestState", "ready")
+                setFieldValue("requestState", "asfuohasfuoh")
+              }}>
+                Submit
+              </button>
+            </form>
+          );
+        }}
+      />;
+  })
+
+  describe("FormikActions", () => {
+    describe("setStatus", () => {
+      it("passes when using setStatus properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setStatus("done");
+        };
+      });
+
+      it("raises error when passed more than one argument", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[extra-arg] - no more than 1 argument is expected
+          actions.setStatus("text", "done");
+        };
+      });
+    });
+
+    describe("setErrors", () => {
+      it("passes when using setErrors properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setErrors({ text: "Text is required" });
+        };
+      });
+
+      it("raises error when passed an unrecognized value key", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[prop-missing] setErrors keys must match value fields
+          actions.setErrors({ other: "Text is required" });
+        };
+      });
+    });
+
+    describe("setSubmitting", () => {
+      it("passes when using setSubmitting properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setSubmitting(false);
+        };
+      });
+
+      it("raises error when passed a non-boolean", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[incompatible-call] setSubmitting only takes a boolean
+          actions.setSubmitting("false");
+        };
+      });
+    });
+
+    describe("setTouched", () => {
+      it("passes when using setTouched properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setTouched({
+            text: true
+          });
+        };
+      });
+
+      it("raises error when passed an unrecognized field or a non-boolean", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[prop-missing] - property `other` is missing in `Values`
+          actions.setTouched({ other: true });
+           // $FlowExpectedError[incompatible-call] - string is incompatible with boolean
+          actions.setTouched({ text: "true" });
+        };
+      });
+    });
+
+    describe("setValues", () => {
+      it("passes when using setValues properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setValues({
+            text: "Text"
+          });
+        };
+      });
+
+      it("raises error when passed something other than Values", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[prop-missing] - property `text` is missing in object
+          actions.setValues({ other: "Text" });
+        };
+      });
+    });
+
+    describe("setFieldValue", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setFieldValue("text", "Value");
+          actions.setFieldValue("text", "Value", true);
+          // $FlowExpectedError[prop-missing] - property `other` is missing in `Values` 
+          actions.setFieldValue("other", "Value");
+        };
+      });
+
+      it("raises error when not passed a field", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[incompatible-call] - object literal is incompatible with key set
+          actions.setFieldValue<$Keys<Values>>({ text: "Text" });
+        };
+      });
+    });
+
+    describe("setFieldError", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setFieldError("text", "Error");
+           // $FlowExpectedError[prop-missing] - property `other` is missing in `Values`
+          actions.setFieldError("other", "Error");
+        };
+      });
+
+      it("raises error when field does not exist", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[prop-missing] - property `Error` is missing in `Values`
+          actions.setFieldError("Error",'');
+        };
+      });
+
+      it("raises error when not passed a field", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[incompatible-call] - function requires another argument
+          actions.setFieldError("text");
+        };
+      });
+    });
+
+    describe("setFieldTouched", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setFieldTouched("text", true);
+          // $FlowExpectedError[prop-missing] - 'other' is not a key in values
+          actions.setFieldTouched("other", true);
+        };
+      });
+
+      it("raises error when not passed a field", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[incompatible-call] - Field and value arguments expected
+          actions.setFieldTouched(true);
+        };
+      });
+    });
+
+    describe("validateForm", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.validateForm();
+          actions.validateForm({ text: "Text" });
+        };
+      });
+    });
+
+    describe("resetForm", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.resetForm();
+          actions.resetForm({ text: "Text" });
+        };
+      });
+
+      it("raises error if pass multiple arguments", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[extra-arg] - resetForm expects 0 or 1 arguments
+          actions.resetForm("text", "Text");
+        };
+      });
+    });
+
+    describe("submitForm", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.submitForm();
+        };
+      });
+
+      it("raises error if passed an argument", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[extra-arg] - submitForm expects no arguments
+          actions.submitForm({ text: "Text" });
+        };
+      });
+    });
+
+    describe("setFormikState", () => {
+      it("passes when used properly", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          actions.setFormikState(({ values }) => ({
+            values: { text: `#${values.text}` }
+          }));
+          actions.setFormikState(
+            ({ errors }) => ({
+              errors: { ...errors, text: "Text is required" }
+            }),
+            () => {}
+          );
+        };
+      });
+
+      it("raises error if return state shape other than FormikState<Values>", () => {
+        const testFunc = (actions: FormikActions<Values>) => {
+          // $FlowExpectedError[prop-missing] - must return correct state shape
+          actions.setFormikState(({ values }) => ({
+            text: `#${values.text}`
+          }));
+        };
+      });
+    });
+  });
+
+  describe("<Form /> and <Field />", () => {
+    it("passes when used properly", () => {
+      const CustomInputComponent = (props: FieldProps) => <input />;
+
+      <Form>
+        <Field type="email" name="email" placeholder="Email" />
+        <Field component="select" name="color">
+          <option value="red">Red</option>
+          <option value="green">Green</option>
+          <option value="blue">Blue</option>
+        </Field>
+        <Field component={CustomInputComponent} name="firstName" />
+      </Form>;
+    });
+  });
+});
diff --git a/definitions/npm/formik_v2.x.x/flow_v0.104.x-/formik_v2.x.x.js b/definitions/npm/formik_v2.x.x/flow_v0.104.x-v0.200.x/formik_v2.x.x.js
similarity index 100%
rename from definitions/npm/formik_v2.x.x/flow_v0.104.x-/formik_v2.x.x.js
rename to definitions/npm/formik_v2.x.x/flow_v0.104.x-v0.200.x/formik_v2.x.x.js
diff --git a/definitions/npm/formik_v2.x.x/flow_v0.104.x-/test_formik.js b/definitions/npm/formik_v2.x.x/flow_v0.104.x-v0.200.x/test_formik.js
similarity index 100%
rename from definitions/npm/formik_v2.x.x/flow_v0.104.x-/test_formik.js
rename to definitions/npm/formik_v2.x.x/flow_v0.104.x-v0.200.x/test_formik.js
diff --git a/definitions/npm/formik_v2.x.x/flow_v0.201.x-/formik_v2.x.x.js b/definitions/npm/formik_v2.x.x/flow_v0.201.x-/formik_v2.x.x.js
new file mode 100644
index 0000000000..fd49589722
--- /dev/null
+++ b/definitions/npm/formik_v2.x.x/flow_v0.201.x-/formik_v2.x.x.js
@@ -0,0 +1,454 @@
+declare module 'formik/@@yup' {
+  declare export type Schema = any;
+  declare export type YupError = any;
+}
+
+declare module 'formik/@flow-typed' {
+  import type { Schema } from 'formik/@@yup';
+
+  declare export type FieldValidator = (
+    value: any
+  ) => ?string | Promise<?string>;
+  declare export type FormikErrors<Values> = $ObjMap<Values, () => ?string>;
+  declare export type FormikTouched<Values> = $ObjMap<Values, () => ?boolean>;
+
+  declare export type FormikState<Values> = {|
+    values: Values,
+    errors: FormikErrors<Values>,
+    touched: FormikTouched<Values>,
+    isSubmitting: boolean,
+    isValidating: boolean,
+    submitCount: number,
+    status?: any,
+  |};
+
+  declare export type FormikComputedProps<Values> = {|
+    dirty: boolean,
+    isValid: boolean,
+    initialValues: Values,
+    initialErrors: FormikErrors<Values>,
+    initialTouched: FormikTouched<Values>,
+    initialStatus?: any,
+  |};
+
+  declare export type FormikHelpers<Values> = {|
+    setStatus(status?: any): void,
+    setErrors(errors: FormikErrors<Values>): void,
+    setSubmitting(isSubmitting: boolean): void,
+    setTouched(touched: FormikTouched<Values>): void,
+    setValues(values: Values): void,
+    setFieldValue(fieldName: string, value: any, shouldValidate?: boolean): void,
+    setFieldError(fieldName: $Keys<Values>, message: string): void,
+    setFieldTouched(fieldName: $Keys<Values>, isTouched?: boolean, shouldValidate?: boolean): void,
+    validateForm(values?: $Shape<Values>): Promise<FormikErrors<Values>>,
+    validateField(field: string): void,
+    resetForm(nextState?: $Shape<FormikState<Values>>): void,
+    setFormikState(
+      state:
+        | FormikState<Values>
+        | ((prevState: FormikState<Values>) => FormikState<Values>),
+      callback?: () => void
+    ): void,
+  |};
+
+  declare export type FormikHandlers = {|
+    handleSubmit(e?: {...}): void,
+    handleReset(e?: {...}): void,
+    handleBlur(eventOrString: string | {...}): void,
+    handleChange(eventOrPath: string | {...}): void,
+  |};
+
+  declare export type FormikSharedConfig = {|
+    validateOnChange?: boolean,
+    validateOnBlur?: boolean,
+    isInitialValid?: boolean | ((props: {...}) => boolean),
+    enableReinitialize?: boolean,
+  |};
+
+  declare export type FormikConfig<Values> = {|
+    ...FormikSharedConfig,
+    onSubmit: (values: Values, formikHelpers: FormikHelpers<Values>) => void | Promise<any>,
+
+    component?: React$ComponentType<FormikProps<Values>> | React$Node,
+    render?: (props: FormikProps<Values>) => React$Node,
+    children?: ((props: FormikProps<Values>) => React$Node) | React$Node,
+    initialValues?: $Shape<Values>,
+    initialStatus?: any,
+    initialErrors?: FormikErrors<Values>,
+    initialTouched?: FormikTouched<Values>,
+    onReset?: (values: Values, formikHelpers: FormikHelpers<Values>) => void,
+    validationSchema?: (() => Schema) | Schema,
+    validate?: (values: Values) => void | {...} | Promise<FormikErrors<Values>>,
+    innerRef?: { current: FormikProps<Values> | null, ... },
+  |};
+
+  declare export type FormikProps<Values> = $ReadOnly<{|
+    ...FormikSharedConfig,
+    ...FormikState<Values>,
+    ...FormikHelpers<Values>,
+    ...FormikHandlers,
+    ...FormikComputedProps<Values>,
+    ...FormikRegistration<Values>,
+    submitForm: () => Promise<void>,
+  |}>;
+
+  declare export type FnsOptions = {|
+    validate: FieldValidator,
+  |};
+
+  declare export type FormikRegistration<Values> = {|
+    unregisterField(fieldName: $Keys<Values>): void,
+    registerField(fieldName: $Keys<Values>, fns: FnsOptions): void,
+  |};
+
+  declare export type FormikContext<Values> = FormikProps<Values> & {
+    validate: $ElementType<FormikConfig<Values>, 'validate'>,
+    validationSchema: $ElementType<FormikConfig<Values>, 'validationSchema'>,
+    ...
+  };
+
+  declare export interface SharedRenderProps<T> {
+    component?: React$ElementType;
+    render?: (props: T) => React$Node;
+    children?: (props: T) => React$Node;
+  }
+
+  declare export type FieldMetaProps<Value> = $ReadOnly<{|
+    value: Value,
+    error?: string,
+    touched: boolean,
+    initialValue?: Value,
+    initialTouched: boolean,
+    initialError?: string,
+  |}>;
+
+  declare export type FieldInputProps<Value> = $ReadOnly<{|
+    value: Value,
+    name: string,
+    multiple?: boolean,
+    checked?: boolean,
+    onChange: $ElementType<FormikHandlers, 'handleChange'>,
+    onBlur: $ElementType<FormikHandlers, 'handleBlur'>,
+  |}>;
+
+  declare export type FieldHelperProps = $ReadOnly<{|
+    setValue: (value: any, shouldValidate?: boolean) => void,
+    setTouched: (value: boolean, shouldValidate?: boolean) => void,
+    setError: (value: any) => void,
+  |}>;
+}
+
+declare module 'formik/@withFormik' {
+  import type { Schema } from 'formik/@@yup';
+  import type {
+    FormikHelpers,
+    FormikProps,
+    FormikSharedConfig,
+    FormikTouched,
+    FormikErrors,
+  } from 'formik/@flow-typed';
+
+  declare export type InjectedFormikProps<Props, Values> = $ReadOnly<{|
+    ...FormikProps<Values>,
+    ...$Exact<Props>,
+  |}>;
+
+  declare export type FormikBag<Props, Values> = $ReadOnly<{|
+    ...FormikHelpers<Values>,
+    props: Props,
+  |}>;
+
+  declare export type WithFormikConfig<Props, Values> = {|
+    ...FormikSharedConfig,
+
+    handleSubmit: (values: Values, formikBag: FormikBag<Props, Values>) => void,
+
+    displayName?: string,
+    mapPropsToValues?: (props: Props) => $Shape<Values>,
+    mapPropsToStatus?: (props: Props) => any,
+    mapPropsToTouched?: (props: Props) => FormikTouched<Values>,
+    mapPropsToErrors?: (props: Props) => FormikErrors<Values>,
+    validate?: (values: Values, props: Props) => void | {...} | Promise<any>,
+
+    validationSchema?: ((props: Props) => Schema) | Schema,
+  |};
+
+  declare export function withFormik<Props: {...}, Values: {...}>(
+    options: WithFormikConfig<Props, Values>
+  ): (
+    component: React$ComponentType<InjectedFormikProps<Props, Values>>
+  ) => React$ComponentType<Props>;
+}
+
+declare module 'formik/@Field' {
+  import type {
+    FormikProps,
+    FieldMetaProps,
+    FieldInputProps,
+    FieldValidator,
+    FieldHelperProps,
+  } from 'formik/@flow-typed';
+
+  declare export type FieldProps<Value> = {|
+    field: FieldInputProps<Value>,
+    form: FormikProps<Value>,
+    meta: FieldMetaProps<Value>,
+  |};
+
+  declare export type FieldConfig<Value> = {|
+    name: string,
+    component?: React$ElementType,
+    as?: React$ElementType,
+    render?: (props: FieldProps<Value>) => React$Node,
+    children?: ((props: FieldProps<Value>) => React$Node) | React$Node,
+    validate?: FieldValidator,
+    type?: string,
+    value?: Value,
+    innerRef?: React$Ref<any>,
+  |};
+
+  declare export type FieldAttributes<Props, Value> = { ...FieldConfig<Value>, ... } & Props;
+
+  declare export type UseFieldConfig<Value> = {
+    name: string,
+    type?: string,
+    value?: Value,
+    as?: React$ElementType,
+    multiple?: boolean,
+    ...
+  };
+
+  declare export function useField<Value>(
+    propsOrFieldName: string | UseFieldConfig<Value>
+  ): [FieldInputProps<Value>, FieldMetaProps<Value>, FieldHelperProps];
+
+  declare export var Field: { <Props, Value>(props: FieldAttributes<Props, Value>): React$Node, ... };
+
+  declare export var FastField: typeof Field;
+}
+
+declare module 'formik/@utils' {
+  declare export function isFunction(value: any): boolean;
+  declare export function isObject(value: any): boolean;
+  declare export function isInteger(value: any): boolean;
+  declare export function isString(value: any): boolean;
+  declare export function isNaN(value: any): boolean;
+  declare export function isEmptyChildren(value: any): boolean;
+  declare export function isPromise(value: any): boolean;
+  declare export function isInputEvent(value: any): boolean;
+  declare export function getActiveElement(doc?: Document): Element | null;
+  declare export function getIn(
+    obj: any,
+    key: string | Array<string>,
+    def?: any,
+    p?: number
+  ): any;
+  declare export function setIn(obj: any, path: string, value: any): any;
+  declare export function setNestedObjectValues<T>(
+    object: any,
+    value: any,
+    visited?: any,
+    response?: any
+  ): T;
+}
+
+declare module 'formik/@FormikContext' {
+  import type { FormikContext } from 'formik/@flow-typed';
+
+  declare type _Context = React$Context<FormikContext<{...}>>;
+
+  declare export var FormikProvider: $ElementType<_Context, 'Provider'>;
+  declare export var FormikConsumer: $ElementType<_Context, 'Consumer'>;
+
+  declare export function useFormikContext<Values>(): FormikContext<Values>;
+}
+
+declare module 'formik/@ErrorMessage' {
+  declare export type ErrorMessageProps = {
+    name: string,
+    className?: string,
+    component?: React$ElementType,
+    render?: (errorMessage: string) => React$Node,
+    children?: (errorMessage: string) => React$Node,
+    ...
+  };
+
+  declare export var ErrorMessage: React$ComponentType<ErrorMessageProps>;
+}
+
+declare module 'formik/@FieldArray' {
+  import type { SharedRenderProps, FormikProps } from 'formik/@flow-typed';
+
+  declare export type FieldArrayRenderProps<Values> = ArrayHelpers & {
+    form: FormikProps<Values>,
+    name: string,
+    ...
+  };
+
+  declare export type FieldArrayConfig<Values> = {
+    name: string,
+    validateOnChange?: boolean,
+    ...
+  } & SharedRenderProps<FieldArrayRenderProps<Values>>;
+
+  declare export type ArrayHelpers = {
+    push: (obj: any) => void,
+    handlePush: (obj: any) => () => void,
+    swap: (indexA: number, indexB: number) => void,
+    handleSwap: (indexA: number, indexB: number) => () => void,
+    move: (from: number, to: number) => void,
+    handleMove: (from: number, to: number) => () => void,
+    insert: (index: number, value: any) => void,
+    handleInsert: (index: number, value: any) => () => void,
+    replace: (index: number, value: any) => void,
+    handleReplace: (index: number, value: any) => () => void,
+    unshift: (value: any) => number,
+    handleUnshift: (value: any) => () => void,
+    handleRemove: (index: number) => () => void,
+    handlePop: () => () => void,
+    remove<T>(index: number): ?T,
+    pop<T>(): ?T,
+    ...
+  };
+
+  declare export function move<T>(
+    array: Array<T>,
+    from: number,
+    to: number
+  ): Array<T>;
+  declare export function swap<T>(
+    array: Array<T>,
+    indexA: number,
+    indexB: number
+  ): Array<T>;
+  declare export function insert<T>(
+    array: Array<T>,
+    index: number,
+    value: T
+  ): Array<T>;
+  declare export function replace<T>(
+    array: Array<T>,
+    index: number,
+    value: T
+  ): Array<T>;
+
+  declare export var FieldArray: { <Values>(props: FieldArrayConfig<Values>): React$Node, ... };
+}
+
+declare module 'formik/@Form' {
+  declare export type HTMLFormAttributes = {
+    // `onSubmit` and `onReset` are not overwritable props
+    // https://github.com/jaredpalmer/formik/blob/next/docs/api/form.md
+    onSubmit?: empty,
+    onReset?: empty,
+    ...
+  };
+
+  declare export var Form: React$StatelessFunctionalComponent<HTMLFormAttributes>;
+}
+
+declare module 'formik/@Formik' {
+  import type { UseFieldConfig } from 'formik/@Field';
+  import type { YupError, Schema } from 'formik/@@yup';
+  import type {
+    FormikConfig,
+    FormikErrors,
+    FormikState,
+    FormikTouched,
+    FieldMetaProps,
+    FieldInputProps,
+  } from 'formik/@flow-typed';
+
+  declare export function useFormik<Values>(
+    options: FormikConfig<Values>
+  ): {
+    initialValues: $Shape<Values>,
+    initialErrors: FormikErrors<Values>,
+    initialTouched: FormikTouched<Values>,
+    initialStatus: any,
+    handleBlur(fieldName: $Keys<Values>): (event: {...}) => void,
+    handleBlur(event: {...}): void,
+    handleChange(fieldName: $Keys<Values>): (event: {...}) => void,
+    handleChange(event: {...}): void,
+    handleReset: (e?: {...}) => void,
+    handleSubmit: (e?: {...}) => void,
+    resetForm: (nextState?: $Shape<FormikState<Values>>) => void,
+    setErrors: (errors: FormikErrors<Values>) => void,
+    setFormikState: (
+      stateOrCb:
+        | FormikState<Values>
+        | ((state: FormikState<Values>) => FormikState<Values>)
+    ) => void,
+    setFieldTouched: (
+      fieldName: $Keys<Values>,
+      touched?: boolean,
+      shouldValidate?: boolean
+    ) => void,
+    setFieldValue: <Name: $Keys<Values>>(
+      fieldName: Name,
+      value: $ElementType<Values, Name>,
+      shouldValidate?: boolean
+    ) => void,
+    setFieldError: (fieldName: $Keys<Values>, value: ?string) => void,
+    setStatus: (status: any) => void,
+    setSubmitting: (isSubmitting: boolean) => void,
+    setTouched: (touched: FormikTouched<Values>) => void,
+    setValues: (values: $Shape<Values>) => void,
+    submitForm: () => Promise<void>,
+    validateForm: (values?: Values) => Promise<FormikErrors<Values>>,
+    validateField: (name: $Keys<Values>) => Promise<?string>,
+    isValid: boolean,
+    dirty: boolean,
+    unregisterField: (name: string) => void,
+    registerField: (name: string, options: {| validate: any |}) => void,
+    getFieldProps<Name>(
+      name: Name | UseFieldConfig<Name>
+    ): [
+      FieldInputProps<$ElementType<Values, Name>>,
+      FieldMetaProps<$ElementType<Values, Name>>
+    ],
+    validateOnBlur: boolean,
+    validateOnChange: boolean,
+    values: Values,
+    errors: FormikErrors<Values>,
+    touched: FormikTouched<Values>,
+    isSubmitting: boolean,
+    isValidating: boolean,
+    status?: any,
+    submitCount: number,
+    ...
+  };
+
+  declare export var Formik: { <Values>(props: FormikConfig<Values>): React$Node, ... };
+
+  declare export function yupToFormErrors<Values>(
+    yupError: YupError
+  ): FormikErrors<Values>;
+
+  declare export function validateYupSchema<Values>(
+    values: Values,
+    schema: Schema,
+    sync?: boolean,
+    context?: any
+  ): Promise<$Shape<Values>>;
+}
+
+declare module 'formik/@connect' {
+  declare export function connect<Config, Comp: React$ComponentType<Config>>(
+    c: Comp
+  ): React$ComponentType<$Diff<React$ElementConfig<Comp>, { formik: any, ... }>>;
+}
+
+declare module 'formik' {
+  declare export * from 'formik/@connect'
+  declare export * from 'formik/@ErrorMessage'
+  declare export * from 'formik/@Field'
+  declare export * from 'formik/@FieldArray'
+  declare export * from 'formik/@flow-typed'
+  declare export * from 'formik/@flow-typed'
+  declare export * from 'formik/@Form'
+  declare export * from 'formik/@Formik'
+  declare export * from 'formik/@FormikContext'
+  declare export * from 'formik/@utils'
+  declare export * from 'formik/@withFormik'
+}
diff --git a/definitions/npm/formik_v2.x.x/flow_v0.201.x-/test_formik.js b/definitions/npm/formik_v2.x.x/flow_v0.201.x-/test_formik.js
new file mode 100644
index 0000000000..b7e058afbf
--- /dev/null
+++ b/definitions/npm/formik_v2.x.x/flow_v0.201.x-/test_formik.js
@@ -0,0 +1,379 @@
+// @flow
+import React from 'react';
+import { it, describe } from 'flow-typed-test';
+import {
+  Form,
+  getActiveElement,
+  getIn,
+  setIn,
+  setNestedObjectValues,
+  ErrorMessage,
+  FormikProvider,
+  FormikConsumer,
+  useFormikContext,
+  Field,
+  FastField,
+  isFunction,
+  isObject,
+  isInteger,
+  isString,
+  isNaN,
+  isEmptyChildren,
+  isPromise,
+  isInputEvent,
+  useField,
+  withFormik,
+  move,
+  swap,
+  insert,
+  replace,
+  FieldArray,
+  useFormik,
+  Formik,
+  type InjectedFormikProps,
+} from 'formik';
+
+describe('withFormik HOC', () => {
+  type FormValues = {| age: number, name: string, birthday: Date |};
+
+  describe('wrapped component props', () => {
+    type FormOwnProps = {|
+      onSubmit: FormValues => void,
+      variant: 'active' | 'passive',
+    |};
+
+    const MyForm = (props: InjectedFormikProps<FormOwnProps, FormValues>) =>
+      null;
+
+    const WithFormikForm = withFormik<FormOwnProps, FormValues>({
+      handleSubmit(values, { props: { onSubmit }, setSubmitting }) {
+        onSubmit(values);
+        setSubmitting(false);
+      },
+    })(MyForm);
+
+    it('should work  when pass valid own props', () => {
+      <WithFormikForm variant={'active'} onSubmit={(v: FormValues) => {}} />;
+    });
+
+    it('should raise an error when pass invalid own props', () => {
+      <WithFormikForm
+        // $FlowExpectedError[incompatible-type] -`__active` is missing in enum
+        variant={'__active'}
+        onSubmit={(v: FormValues) => {}}
+      />;
+
+      <WithFormikForm
+        variant={'passive'}
+        // $FlowExpectedError[incompatible-type] - need function
+        onSubmit={123}
+      />;
+    });
+
+    it('should raise an error when pass injected formik props', () => {
+      // $FlowExpectedError[prop-missing] - isSubmitting was extracted
+      <WithFormikForm
+        isSubmitting={false}
+        variant={'active'}
+        onSubmit={(v: FormValues) => {}}
+      />;
+    });
+  });
+
+  describe('HOC config', () => {
+    type Props = {|
+      initialName: string,
+      initialAge: number,
+      initialBirthday: Date,
+    |};
+    const requiredOptions = { handleSubmit: () => {} };
+
+    describe('handleSubmit', () => {
+      it('should pass when use properly', () => {
+        withFormik<Props, FormValues>({
+          handleSubmit(values, { props }) {
+            (values.age: number);
+            (props.initialName: string);
+
+            // $FlowExpectedError[incompatible-cast] - check any
+            (values.age: boolean);
+            // $FlowExpectedError[incompatible-cast] - check any
+            (props.initialName: boolean);
+          },
+        });
+      });
+    });
+
+    describe('handleSubmit', () => {
+      it('should pass when use properly', () => {
+        withFormik<Props, FormValues>({
+          ...requiredOptions,
+          mapPropsToValues: ({ initialAge }) => ({ age: initialAge }),
+        });
+      });
+
+      it('should raise an error when `mapPropsToValues` return invalid values', () => {
+        withFormik<Props, FormValues>({
+          ...requiredOptions,
+          // $FlowExpectedError[incompatible-call] - `initialAge` is a number but `name` need a string
+          mapPropsToValues: ({ initialAge }) => ({
+            name: initialAge,
+          }),
+        });
+      });
+
+      it('should raise an error when `mapPropsToValues` return not missing  value', () => {
+        withFormik<Props, FormValues>({
+          ...requiredOptions,
+          // $FlowExpectedError[prop-missing] - `abc` is missing in values
+          mapPropsToValues: ({ initialAge }) => ({
+            abc: initialAge,
+          }),
+        });
+      });
+
+      it('should return partial of values', () => {
+        withFormik<Props, { name: string, age: number, ... }>({
+          ...requiredOptions,
+          mapPropsToValues: ({ initialAge }) => ({
+            age: initialAge,
+          }),
+        });
+      });
+    });
+  });
+});
+
+describe('useField hook', () => {
+  it('should call with string', () => {
+    useField('name');
+  });
+
+  it('also should call with options', () => {
+    useField({ name: 'name' });
+  });
+
+  it('should raise error when pass object without required prop `name`', () => {
+    // $FlowExpectedError[incompatible-call]
+    useField({ __name: 'name' });
+  });
+
+  it('should return field props', () => {
+    const [props, meta] = useField<number>('name');
+
+    (props.value: number);
+    // $FlowExpectedError[incompatible-cast] - check any
+    (props.value: boolean);
+
+    (meta.touched: boolean);
+    // $FlowExpectedError[incompatible-cast] - check any
+    (meta.touched: number);
+
+    (meta.error: ?string);
+    // $FlowExpectedError[incompatible-cast] - check any
+    (meta.error: number);
+  });
+
+  it('should return FieldHelperProps', () => {
+    const [, , helpers] = useField<string>('name');
+
+    helpers.setValue('a name');
+    helpers.setValue('a name', false);
+    helpers.setTouched(true);
+    helpers.setTouched(true, false);
+    helpers.setError('an error');
+  });
+});
+
+describe('Field and FastField', () => {
+  it('should render Field component', () => {
+    <Field name={'email'} />;
+    <FastField name={'email'} />;
+  });
+
+  it('should raise an error when pass incompatible name prop', () => {
+    // $FlowExpectedError[incompatible-type] - `name` must be a string
+    <Field name={111} />;
+
+    // $FlowExpectedError[prop-missing] - `name` is required prop
+    <Field />;
+    // $FlowExpectedError[prop-missing] - `name` is required prop
+    <FastField />;
+  });
+
+  it('should validate value', () => {
+    Field<{ disabled: boolean, ... }, '1' | '2'>({
+      name: 'count',
+      disabled: true,
+      value: '1',
+    });
+
+    Field<{ disabled: boolean, ... }, '1' | '2'>({
+      name: 'count',
+      // $FlowExpectedError[incompatible-call] - need a boolean
+      disabled: 123,
+      // $FlowExpectedError[incompatible-call] - `12` is missing in enum
+      value: '12',
+    });
+  });
+});
+
+describe('utils', () => {
+  it('should work properly', () => {
+    (isFunction(() => {}): boolean);
+    (isObject({}): boolean);
+    (isInteger(1): boolean);
+    (isString(''): boolean);
+    (isNaN(1 / 0): boolean);
+    (isEmptyChildren([]): boolean);
+    (isPromise(Promise.resolve(1)): boolean);
+    (isInputEvent({}): boolean);
+
+    (getActiveElement(document): Element | null);
+
+    getIn({ a: { b: 2 } }, ['a', 'b']);
+    setIn({ a: { b: 2 } }, 'a', 3);
+    setNestedObjectValues({}, 1);
+  });
+});
+
+describe('FormikContext', () => {
+  it('should work properly', () => {
+    <FormikConsumer>
+      {value => {
+        (value.validateOnBlur: ?boolean);
+
+        // $FlowExpectedError[incompatible-cast] - check any
+        (value.validateOnBlur: ?string);
+
+        (value.submitForm: () => Promise<void>);
+
+        // $FlowExpectedError[incompatible-cast] - check any
+        (value.submitForm: number);
+
+        return null;
+      }}
+    </FormikConsumer>;
+
+    // $FlowExpectedError[incompatible-type] - need valid formik context value
+    <FormikProvider value={123} />;
+  });
+
+  it('should return context with passed values', () => {
+    const context = useFormikContext<{ age: number, ... }>();
+
+    (context.values.age: number);
+    // $FlowExpectedError[incompatible-cast] - check any
+    (context.values.age: string);
+  });
+});
+
+describe('ErrorMessage', () => {
+  it('should work properly', () => {
+    <ErrorMessage name={'password'} />;
+
+    <ErrorMessage
+      name={'password'}
+      className={undefined}
+      component={undefined}
+      render={undefined}
+    >
+      {undefined}
+    </ErrorMessage>;
+
+    <ErrorMessage
+      name={'password'}
+      className={'c-error'}
+      component={'div'}
+      render={val => {
+        (val: string);
+
+        return null;
+      }}
+    >
+      {val => {
+        (val: string);
+
+        return null;
+      }}
+    </ErrorMessage>;
+  });
+
+  it('should raise an error when do not pass required prop `name`', () => {
+    // $FlowExpectedError[prop-missing]
+    <ErrorMessage />;
+  });
+});
+
+describe('FieldArray', () => {
+  describe('methods', () => {
+    (move([1], 1, 1): Array<number>);
+    (swap(['str'], 1, 1): Array<string>);
+    (insert([true], 1, false): Array<boolean>);
+    (replace(['1'], 1, '2'): Array<string>);
+  });
+
+  describe('Component', () => {
+    it('should render FieldArray component', () => {
+      <FieldArray name={'email'} />;
+    });
+
+    it('should raise an error when pass incompatible name prop', () => {
+      // $FlowExpectedError[incompatible-type] - `name` must be a string
+      <FieldArray name={111} />;
+
+      // $FlowExpectedError[prop-missing] - `name` is required prop
+      <FieldArray />;
+    });
+  });
+});
+
+it('should render Form', () => {
+  <Form />;
+
+  <Form aria-hidden={'true'} />;
+
+  // $FlowExpectedError[incompatible-type] - `onSubmit` already provided to `form` yuo can't overwrite it
+  <Form onSubmit={() => {}} />;
+
+  // $FlowExpectedError[incompatible-type] - `onReset` already provided to `form` yuo can't overwrite it
+  <Form onReset={() => {}} />;
+});
+
+describe('Formik', () => {
+  describe('Component', () => {
+    it('should work properly', () => {
+      <Formik onSubmit={() => {}} />;
+    });
+    it('onSumbit can return promise', () => {
+      <Formik onSubmit={() => Promise.resolve(null)} />;
+    });
+  });
+
+  describe('hook', () => {
+    it('should work properly', () => {
+      type Vals = {|
+        name: string,
+        age: number,
+      |};
+
+      const formik = useFormik<Vals>({ onSubmit: () => {} });
+
+      formik.setFieldValue('name', '1', true);
+
+      // $FlowExpectedError[prop-missing] - `name` is missing in `Values`
+      formik.setFieldValue('__name', '1');
+
+      // $FlowExpectedError[incompatible-call] - `name` expect string value, not `123`
+      formik.setFieldValue('name', 123);
+
+      (formik.values.name: string);
+      (formik.values.age: number);
+
+      // $FlowExpectedError[incompatible-cast] - check any
+      (formik.values.name: boolean);
+      // $FlowExpectedError[incompatible-cast] - check any
+      (formik.values.age: boolean);
+    });
+  });
+});
diff --git a/definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-/fuse.js_v6.x.x.js b/definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-v0.200.x/fuse.js_v6.x.x.js
similarity index 100%
rename from definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-/fuse.js_v6.x.x.js
rename to definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-v0.200.x/fuse.js_v6.x.x.js
diff --git a/definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-/test_fuse.js_v6.x.x.js b/definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-v0.200.x/test_fuse.js_v6.x.x.js
similarity index 100%
rename from definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-/test_fuse.js_v6.x.x.js
rename to definitions/npm/fuse.js_v6.x.x/flow_v0.106.x-v0.200.x/test_fuse.js_v6.x.x.js
diff --git a/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/fuse.js_v6.x.x.js b/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/fuse.js_v6.x.x.js
new file mode 100644
index 0000000000..8fdc98c9d0
--- /dev/null
+++ b/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/fuse.js_v6.x.x.js
@@ -0,0 +1,344 @@
+// @flow
+
+declare module 'fuse.js' {
+  declare export default typeof Fuse;
+  declare class Fuse<T> {
+    constructor(
+      list: $ReadOnlyArray<T>,
+      options?: Fuse$IFuseOptions<T>,
+      index?: Fuse$FuseIndex<T>
+    ): this;
+
+    /**
+     * Search function for the Fuse instance.
+     *
+     * ```typescript
+     * const list: MyType[] = [myType1, myType2, etc...]
+     *
+     * const options: Fuse.IFuseOptions<MyType> = {
+     *  keys: ['key1', 'key2']
+     * }
+     *
+     * const myFuse = new Fuse(list, options)
+     * let result = myFuse.search('pattern')
+     * ```
+     * @param pattern The pattern to search
+     * @param options `Fuse.FuseSearchOptions`
+     * @returns An array of search results
+     */
+    search<R>(
+      pattern: string | Fuse$Expression,
+      options?: Fuse$FuseSearchOptions
+    ): Fuse$FuseResult<R>[];
+    setCollection(docs: $ReadOnlyArray<T>, index?: Fuse$FuseIndex<T>): void;
+
+    /**
+     * Adds a doc to the end the list.
+     */
+    add(doc: T): void;
+
+    /**
+     * Removes all documents from the list which the predicate returns truthy for,
+     * and returns an array of the removed docs.
+     * The predicate is invoked with two arguments: (doc, index).
+     */
+    remove(predicate: (doc: T, idx: number) => boolean): T[];
+
+    /**
+     * Removes the doc at the specified index.
+     */
+    removeAt(idx: number): void;
+
+    /**
+     * Returns the generated Fuse index
+     */
+    getIndex(): Fuse$FuseIndex<T>;
+
+    /**
+     * Return the current version.
+     */
+    static version: string;
+
+    /**
+     * Use this method to pre-generate the index from the list, and pass it
+     * directly into the Fuse instance.
+     *
+     * _Note that Fuse will automatically index the table if one isn't provided
+     * during instantiation._
+     *
+     * ```typescript
+     * const list: MyType[] = [myType1, myType2, etc...]
+     *
+     * const index = Fuse.createIndex<MyType>(
+     *  keys: ['key1', 'key2']
+     *  list: list
+     * )
+     *
+     * const options: Fuse.IFuseOptions<MyType> = {
+     *  keys: ['key1', 'key2']
+     * }
+     *
+     * const myFuse = new Fuse(list, options, index)
+     * ```
+     * @param keys The keys to index
+     * @param list The list from which to create an index
+     * @param options ?
+     * @returns An indexed list
+     */
+    static createIndex<U>(
+      keys: Array<Fuse$FuseOptionKey<U>>,
+      list: $ReadOnlyArray<U>,
+      options?: Fuse$FuseIndexOptions<U>
+    ): Fuse$FuseIndex<U>;
+    static parseIndex<U>(
+      index: any,
+      options?: Fuse$FuseIndexOptions<U>
+    ): Fuse$FuseIndex<U>;
+    static config: typeof Fuse$config;
+    static FuseIndex: typeof Fuse$FuseIndex;
+  }
+
+  declare export class Fuse$FuseIndex<T> {
+    constructor(options?: Fuse$FuseIndexOptions<T>): this;
+    setSources(docs: $ReadOnlyArray<T>): void;
+    setKeys(keys: $ReadOnlyArray<string>): void;
+    setIndexRecords(records: Fuse$FuseIndexRecords): void;
+    create(): void;
+    add(doc: T): void;
+    toJSON(): {
+      keys: $ReadOnlyArray<string>,
+      records: Fuse$FuseIndexRecords,
+      ...
+    };
+  }
+
+  declare type Fuse$FuseGetFunction<T> = (
+    obj: T,
+    path: string | string[]
+  ) => $ReadOnlyArray<string> | string;
+
+  declare export type Fuse$FuseIndexOptions<T> = {
+    getFn: Fuse$FuseGetFunction<T>,
+    ...
+  };
+
+  declare export type Fuse$FuseSortFunctionItem = {
+    [key: string]:
+      | {
+          $: string,
+          ...
+        }
+      | {
+          $: string,
+          idx: number,
+          ...
+        }[],
+    ...
+  };
+
+  declare export type Fuse$FuseSortFunctionMatch = {
+    score: number,
+    key: string,
+    value: string,
+    indices: $ReadOnlyArray<number>[],
+    ...
+  };
+
+  declare export type Fuse$FuseSortFunctionMatchList = {
+    ...Fuse$FuseSortFunctionMatch,
+    ...{
+      idx: number,
+      ...
+    },
+    ...
+  };
+
+  declare export type Fuse$FuseSortFunctionArg = {
+    idx: number,
+    item: Fuse$FuseSortFunctionItem,
+    score: number,
+    matches?: (Fuse$FuseSortFunctionMatch | Fuse$FuseSortFunctionMatchList)[],
+    ...
+  };
+
+  declare export type Fuse$FuseSortFunction = (
+    a: Fuse$FuseSortFunctionArg,
+    b: Fuse$FuseSortFunctionArg
+  ) => number;
+
+  declare type Fuse$RecordEntryObject = {
+    v: string,
+    n: number,
+    ...
+  };
+
+  declare type Fuse$RecordEntryArrayItem = $ReadOnlyArray<{
+    ...Fuse$RecordEntryObject,
+    ...{
+      i: number,
+      ...
+    },
+    ...
+  }>;
+
+  declare type Fuse$RecordEntry = {
+    [key: string]: Fuse$RecordEntryObject | Fuse$RecordEntryArrayItem,
+    ...
+  };
+
+  declare type Fuse$FuseIndexObjectRecord = {
+    i: number,
+    $: Fuse$RecordEntry,
+    ...
+  };
+
+  declare type Fuse$FuseIndexStringRecord = {
+    i: number,
+    v: string,
+    n: number,
+    ...
+  };
+
+  declare type Fuse$FuseIndexRecords =
+    | $ReadOnlyArray<Fuse$FuseIndexObjectRecord>
+    | $ReadOnlyArray<Fuse$FuseIndexStringRecord>;
+
+  declare export type Fuse$FuseOptionKeyObject<T> = {
+    name: string | string[],
+    weight?: number,
+    getFn?: (obj: T) => $ReadOnlyArray<string> | string,
+    ...
+  };
+
+  declare export type Fuse$FuseOptionKey<T> =
+    | Fuse$FuseOptionKeyObject<T>
+    | string
+    | string[];
+
+  declare interface RequiredIFuseOptions<T> {
+    /**
+     * Indicates whether comparisons should be case sensitive.
+     */
+    isCaseSensitive: boolean;
+
+    /**
+     * Determines how close the match must be to the fuzzy location (specified by `location`). An exact letter match which is `distance` characters away from the fuzzy location would score as a complete mismatch. A `distance` of `0` requires the match be at the exact `location` specified. A distance of `1000` would require a perfect match to be within `800` characters of the `location` to be found using a `threshold` of `0.8`.
+     */
+    distance: number;
+
+    /**
+     * When true, the matching function will continue to the end of a search pattern even if a perfect match has already been located in the string.
+     */
+    findAllMatches: boolean;
+
+    /**
+     * The function to use to retrieve an object's value at the provided path. The default will also search nested paths.
+     */
+    getFn: Fuse$FuseGetFunction<T>;
+
+    /**
+     * When `true`, search will ignore `location` and `distance`, so it won't matter where in the string the pattern appears.
+     */
+    ignoreLocation: boolean;
+
+    /**
+     * When `true`, the calculation for the relevance score (used for sorting) will ignore the `field-length norm`.
+     */
+    ignoreFieldNorm: boolean;
+
+    /**
+     * Determines how much the `field-length norm` affects scoring. A value of `0` is equivalent to ignoring the field-length norm. A value of `0.5` will greatly reduce the effect of field-length norm, while a value of `2.0` will greatly increase it.
+     */
+    fieldNormWeight: number;
+
+    /**
+     * Whether the matches should be included in the result set. When `true`, each record in the result set will include the indices of the matched characters. These can consequently be used for highlighting purposes.
+     */
+    includeMatches: boolean;
+
+    /**
+     * Whether the score should be included in the result set. A score of `0`indicates a perfect match, while a score of `1` indicates a complete mismatch.
+     */
+    includeScore: boolean;
+
+    /**
+     * List of keys that will be searched. This supports nested paths, weighted search, searching in arrays of `strings` and `objects`.
+     */
+    keys: Array<Fuse$FuseOptionKey<T>>;
+
+    /**
+     * Determines approximately where in the text is the pattern expected to be found.
+     */
+    location: number;
+
+    /**
+     * Only the matches whose length exceeds this value will be returned. (For instance, if you want to ignore single character matches in the result, set it to `2`).
+     */
+    minMatchCharLength: number;
+
+    /**
+     * Whether to sort the result list, by score.
+     */
+    shouldSort: boolean;
+
+    /**
+     * The function to use to sort all the results. The default will sort by ascending relevance score, ascending index.
+     */
+    sortFn?: Fuse$FuseSortFunction;
+
+    /**
+     * At what point does the match algorithm give up. A threshold of `0.0` requires a perfect match (of both letters and location), a threshold of `1.0` would match anything.
+     */
+    threshold: number;
+
+    /**
+     * When `true`, it enables the use of unix-like search commands. See [example](/examples.html#extended-search).
+     */
+    useExtendedSearch: boolean;
+  }
+  declare export type Fuse$IFuseOptions<T> = $Shape<RequiredIFuseOptions<T>>;
+
+  declare type Fuse$RangeTuple = [number, number];
+
+  declare export type Fuse$FuseResultMatch = {
+    indices: $ReadOnlyArray<Fuse$RangeTuple>,
+    key?: string,
+    refIndex?: number,
+    value?: string,
+    ...
+  };
+
+  declare export type Fuse$FuseSearchOptions = {
+    limit: number,
+    ...
+  };
+
+  declare export type Fuse$FuseResult<T> = {
+    item: T,
+    refIndex: number,
+    score?: number,
+    matches?: $ReadOnlyArray<Fuse$FuseResultMatch>,
+    ...
+  };
+
+  declare export type Fuse$Expression =
+    | {
+        [key: string]: string,
+        ...
+      }
+    | {
+        $path: $ReadOnlyArray<string>,
+        $val: string,
+        ...
+      }
+    | {
+        $and?: Fuse$Expression[],
+        ...
+      }
+    | {
+        $or?: Fuse$Expression[],
+        ...
+      };
+
+  declare export var Fuse$config: RequiredIFuseOptions<any>;
+}
diff --git a/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/test_fuse.js_v6.x.x.js b/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/test_fuse.js_v6.x.x.js
new file mode 100644
index 0000000000..8cb93f09de
--- /dev/null
+++ b/definitions/npm/fuse.js_v6.x.x/flow_v0.201.x-/test_fuse.js_v6.x.x.js
@@ -0,0 +1,83 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+import Fuse from 'fuse.js';
+
+const TEST_LIST = [
+  { id: '001', name: 'Alice', age: 21, role: 'admin', city: 'New York' },
+  { id: '002', name: 'Alii', age: 22, role: 'user', city: 'Paris' },
+  { id: '123', name: 'Bob', age: 22, role: 'admin', city: 'Tokyo' },
+  { id: '124', name: 'Charlie', age: 23, role: 'viewer', city: 'Taipei' },
+  { id: '125', name: 'David', age: 24, role: 'marketing', city: 'Seoul' },
+  { id: '160', name: 'Edward', age: 25, role: 'marketing', city: 'London' },
+  { id: '234', name: 'Frank', age: 26, role: 'viewer', city: 'New York' },
+];
+
+describe('fuse.js constructor', () => {
+  it('should type constructor correctly', () => {
+    const fuse = new Fuse(TEST_LIST);
+  });
+
+  it('should error when required parameter of constructor is missing', () => {
+    // $FlowExpectedError[incompatible-call] `list` is missing
+    const fuse = new Fuse();
+  });
+
+  describe('options', () => {
+    it('should type constructor correctly', () => {
+      const fuse = new Fuse(TEST_LIST, {
+        keys: ['name', 'city'],
+        threshold: 0.3,
+        shouldSort: false,
+        ignoreLocation: true,
+      });
+    });
+
+    it('should error when not support option key been set', () => {
+      // $FlowExpectedError[prop-missing] `notExistOptionKey` is missing in the options
+      const fuse = new Fuse(TEST_LIST, {
+        notExistOptionKey: true,
+        keys: ['name', 'city'],
+        threshold: 0.3,
+        shouldSort: false,
+        ignoreLocation: true,
+      });
+    });
+
+    it('should error when not support option type been set', () => {
+      // $FlowExpectedError[incompatible-call] `threshold` should be `number`
+      const fuse = new Fuse(TEST_LIST, {
+        keys: ['name', 'city'],
+        threshold: true,
+        shouldSort: false,
+        ignoreLocation: true,
+      });
+    });
+  });
+});
+
+describe('fuse.js search', () => {
+  const fuse = new Fuse(TEST_LIST, {
+    keys: ['name', 'city'],
+    threshold: 0.3,
+    shouldSort: false,
+    ignoreLocation: true,
+  });
+
+  it('should type constructor correctly', () => {
+    const results = fuse.search('Alice');
+  });
+
+  it('should error when required parameter of search is missing', () => {
+    // $FlowExpectedError[incompatible-call] `pattern` is missing
+    const results = fuse.search();
+  });
+
+  it('should error when access not exist property from search results', () => {
+    const results = fuse.search('Alice');
+
+    results.map(result => result.item);
+
+    // $FlowExpectedError[prop-missing] `notExistKey` is missing in the result
+    results.map(result => result.notExistKey);
+  });
+});
diff --git a/definitions/npm/history_v4.9.x/flow_v0.104.x-/history_v4.9.x.js b/definitions/npm/history_v4.9.x/flow_v0.104.x-v0.200.x/history_v4.9.x.js
similarity index 100%
rename from definitions/npm/history_v4.9.x/flow_v0.104.x-/history_v4.9.x.js
rename to definitions/npm/history_v4.9.x/flow_v0.104.x-v0.200.x/history_v4.9.x.js
diff --git a/definitions/npm/history_v4.9.x/flow_v0.104.x-/test_history_v4.9.x.js b/definitions/npm/history_v4.9.x/flow_v0.104.x-v0.200.x/test_history_v4.9.x.js
similarity index 100%
rename from definitions/npm/history_v4.9.x/flow_v0.104.x-/test_history_v4.9.x.js
rename to definitions/npm/history_v4.9.x/flow_v0.104.x-v0.200.x/test_history_v4.9.x.js
diff --git a/definitions/npm/history_v4.9.x/flow_v0.201.x-/history_v4.9.x.js b/definitions/npm/history_v4.9.x/flow_v0.201.x-/history_v4.9.x.js
new file mode 100644
index 0000000000..37f2878a35
--- /dev/null
+++ b/definitions/npm/history_v4.9.x/flow_v0.201.x-/history_v4.9.x.js
@@ -0,0 +1,138 @@
+declare module 'history' {
+  declare function Unblock(): void;
+
+  declare export type Action = 'PUSH' | 'REPLACE' | 'POP';
+
+  declare export type BrowserLocation = {
+    pathname: string,
+    search: string,
+    hash: string,
+    // Browser and Memory specific
+    state: {...},
+    key: string,
+    ...
+  };
+
+  declare interface IBrowserHistory {
+    length: number;
+    location: BrowserLocation;
+    action: Action;
+    push(path: string, state?: {...}): void;
+    push(location: $Shape<BrowserLocation>): void;
+    replace(path: string, state?: {...}): void;
+    replace(location: $Shape<BrowserLocation>): void;
+    go(n: number): void;
+    goBack(): void;
+    goForward(): void;
+    listen((location: BrowserLocation, action: Action) => void): void;
+    block(message: string): typeof Unblock;
+    block(
+      (location: BrowserLocation, action: Action) => string
+    ): typeof Unblock;
+  }
+
+  declare export type BrowserHistory = IBrowserHistory;
+
+  declare type BrowserHistoryOpts = {
+    basename?: string,
+    forceRefresh?: boolean,
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+    ...
+  };
+
+  declare function createBrowserHistory(
+    opts?: BrowserHistoryOpts
+  ): BrowserHistory;
+
+  declare export type MemoryLocation = {
+    pathname: string,
+    search: string,
+    hash: string,
+    // Browser and Memory specific
+    state: {...},
+    key: string,
+    ...
+  };
+
+  declare interface IMemoryHistory {
+    length: number;
+    location: MemoryLocation;
+    action: Action;
+    index: number;
+    entries: Array<string>;
+    push(path: string, state?: {...}): void;
+    push(location: $Shape<MemoryLocation>): void;
+    replace(path: string, state?: {...}): void;
+    replace(location: $Shape<MemoryLocation>): void;
+    go(n: number): void;
+    goBack(): void;
+    goForward(): void;
+    // Memory only
+    canGo(n: number): boolean;
+    listen((location: MemoryLocation, action: Action) => void): void;
+    block(message: string): typeof Unblock;
+    block((location: MemoryLocation, action: Action) => string): typeof Unblock;
+  }
+
+  declare export type MemoryHistory = IMemoryHistory;
+
+  declare type MemoryHistoryOpts = {
+    initialEntries?: Array<string>,
+    initialIndex?: number,
+    keyLength?: number,
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+    ...
+  };
+
+  declare function createMemoryHistory(opts?: MemoryHistoryOpts): MemoryHistory;
+
+  declare export type HashLocation = {
+    pathname: string,
+    search: string,
+    hash: string,
+    ...
+  };
+
+  declare interface IHashHistory {
+    length: number;
+    location: HashLocation;
+    action: Action;
+    push(path: string, state?: {...}): void;
+    push(location: $Shape<HashLocation>): void;
+    replace(path: string, state?: {...}): void;
+    replace(location: $Shape<HashLocation>): void;
+    go(n: number): void;
+    goBack(): void;
+    goForward(): void;
+    listen((location: HashLocation, action: Action) => void): void;
+    block(message: string): typeof Unblock;
+    block((location: HashLocation, action: Action) => string): typeof Unblock;
+    push(path: string): void;
+  }
+
+  declare export type HashHistory = IHashHistory;
+
+  declare type HashHistoryOpts = {
+    basename?: string,
+    hashType: 'slash' | 'noslash' | 'hashbang',
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+    ...
+  };
+
+  declare function createHashHistory(opts?: HashHistoryOpts): HashHistory;
+
+  declare function parsePath(path: string): BrowserLocation | MemoryLocation | HashLocation;
+
+  declare function createPath(
+    path: BrowserLocation | MemoryLocation | HashLocation
+  ): string;
+}
diff --git a/definitions/npm/history_v4.9.x/flow_v0.201.x-/test_history_v4.9.x.js b/definitions/npm/history_v4.9.x/flow_v0.201.x-/test_history_v4.9.x.js
new file mode 100644
index 0000000000..b95a7adbd9
--- /dev/null
+++ b/definitions/npm/history_v4.9.x/flow_v0.201.x-/test_history_v4.9.x.js
@@ -0,0 +1,295 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+
+import {createBrowserHistory} from 'history';
+import {createMemoryHistory} from 'history';
+import {createHashHistory} from 'history';
+import {createPath} from 'history';
+import {parsePath} from 'history';
+
+// browser history
+
+describe('browser history', () => {
+  it('should allow to get location fields', () => {
+    const history = createBrowserHistory({
+      basename: "",
+      forceRefresh: false,
+      keyLength: 6,
+    })
+
+    const pathname: string = history.location.pathname
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createBrowserHistory({
+      basename: "",
+      forceRefresh: false,
+      keyLength: 6,
+    })
+
+    const key: string = history.location.key
+    const state: {...} = history.location.state
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createBrowserHistory({
+      basename: "",
+      forceRefresh: false,
+      keyLength: 6,
+    })
+
+    // $FlowExpectedError[prop-missing]
+    history.foo
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: "",
+        forceRefresh: false,
+        keyLength: 6,
+      })
+
+      history.push("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: "",
+        forceRefresh: false,
+        keyLength: 6,
+      })
+
+      history.push({
+        pathname: "/",
+        state: { a: 1 },
+      })
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: "",
+        forceRefresh: false,
+        keyLength: 6,
+      })
+
+      history.replace("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: "",
+        forceRefresh: false,
+        keyLength: 6,
+      })
+
+      history.replace({
+        pathname: "/",
+        state: { a: 1 },
+      })
+    });
+  });
+});
+
+describe('memory history', () => {
+  it('should allow to get location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ["/"],
+      initialIndex: 0,
+      keyLength: 6,
+    })
+
+    const pathname: string = history.location.pathname
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ["/"],
+      initialIndex: 0,
+      keyLength: 6,
+    })
+
+    const key: string = history.location.key
+    const state: {...} = history.location.state
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createMemoryHistory({
+      initialEntries: ["/"],
+      initialIndex: 0,
+      keyLength: 6,
+    })
+
+    // $FlowExpectedError[prop-missing]
+    history.foo
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ["/"],
+        initialIndex: 0,
+        keyLength: 6,
+      })
+
+      history.push("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ["/"],
+        initialIndex: 0,
+        keyLength: 6,
+      })
+
+      history.push({
+        pathname: "/",
+        state: { a: 1 },
+      })
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ["/"],
+        initialIndex: 0,
+        keyLength: 6,
+      })
+
+      history.replace("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ["/"],
+        initialIndex: 0,
+        keyLength: 6,
+      })
+
+      history.replace({
+        pathname: "/",
+        state: { a: 1 },
+      })
+    });
+  });
+});
+
+describe('hash history', () => {
+  it('should allow to get location fields', () => {
+    const history = createHashHistory({
+      basename: "",
+      hashType: "slash",
+    })
+
+    const pathname: string = history.location.pathname
+  });
+
+  it('should not allow to get browser and memory specific location fields', () => {
+    const history = createHashHistory({
+      basename: "",
+      hashType: "slash",
+    })
+
+    // $FlowExpectedError[prop-missing]
+    const key: string = history.location.key
+    // $FlowExpectedError[prop-missing]
+    const state: {...} = history.location.state
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createHashHistory({
+      basename: "",
+      hashType: "slash",
+    })
+
+    // $FlowExpectedError[prop-missing]
+    history.foo
+  });
+
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: "",
+        hashType: "slash",
+      })
+
+      history.push("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: "",
+        hashType: "slash",
+      })
+
+      history.push({
+        search: "?a=1",
+      })
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: "",
+        hashType: "slash",
+      })
+
+      history.replace("/")
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: "",
+        hashType: "slash",
+      })
+
+      history.push({
+        search: "?a=1",
+      })
+    });
+  });
+});
+
+describe('create path', () => {
+  it('should allow to use Location argument', () => {
+    const path = createPath({
+      pathname: '/test',
+      search: '?a=1',
+      hash: 'slug',
+    })
+
+    const key: string = path
+    // $FlowExpectedError[incompatible-type]
+    const state: {...} = path
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-call]
+    const path = createPath()
+
+    const key: string = path
+  });
+});
+
+describe('parse path', () => {
+  it('should allow to use string argument', () => {
+    const location = parsePath('/test?query#hash')
+
+    const state: {...} = location
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-call]
+    const location = parsePath()
+
+    const state: {...} = location
+  });
+});
diff --git a/definitions/npm/history_v4.x.x/flow_v0.104.x-/history_v4.x.x.js b/definitions/npm/history_v4.x.x/flow_v0.104.x-v0.200.x/history_v4.x.x.js
similarity index 100%
rename from definitions/npm/history_v4.x.x/flow_v0.104.x-/history_v4.x.x.js
rename to definitions/npm/history_v4.x.x/flow_v0.104.x-v0.200.x/history_v4.x.x.js
diff --git a/definitions/npm/history_v4.x.x/flow_v0.104.x-/test_history_v4.x.x.js b/definitions/npm/history_v4.x.x/flow_v0.104.x-v0.200.x/test_history_v4.x.x.js
similarity index 100%
rename from definitions/npm/history_v4.x.x/flow_v0.104.x-/test_history_v4.x.x.js
rename to definitions/npm/history_v4.x.x/flow_v0.104.x-v0.200.x/test_history_v4.x.x.js
diff --git a/definitions/npm/history_v4.x.x/flow_v0.201.x-/history_v4.x.x.js b/definitions/npm/history_v4.x.x/flow_v0.201.x-/history_v4.x.x.js
new file mode 100644
index 0000000000..979b18eee5
--- /dev/null
+++ b/definitions/npm/history_v4.x.x/flow_v0.201.x-/history_v4.x.x.js
@@ -0,0 +1,106 @@
+declare module 'history' {
+  declare type Unregister = () => void;
+
+  declare export type Action = 'PUSH' | 'REPLACE' | 'POP';
+
+  declare export type Location = {|
+    pathname: string,
+    search: string,
+    hash: string,
+    state: { ... },
+    key: string,
+  |};
+
+  declare type History<HistoryLocation = Location> = {|
+    length: number,
+    location: HistoryLocation,
+    action: Action,
+    push: ((path: string, state?: { ... }) => void) &
+      ((location: $Shape<HistoryLocation>) => void),
+    replace: ((path: string, state?: { ... }) => void) &
+      ((location: $Shape<HistoryLocation>) => void),
+    go(n: number): void,
+    goBack(): void,
+    goForward(): void,
+    listen((location: HistoryLocation, action: Action) => void): Unregister,
+    block(
+      prompt:
+        | string
+        | boolean
+        | ((location: HistoryLocation, action: Action) => string | false | void)
+    ): Unregister,
+    createHref(location: $Shape<HistoryLocation>): string,
+  |};
+
+  declare export type BrowserHistory = History<>;
+
+  declare type BrowserHistoryOpts = {|
+    basename?: string,
+    forceRefresh?: boolean,
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+    keyLength?: number,
+  |};
+
+  declare function createBrowserHistory(
+    opts?: BrowserHistoryOpts
+  ): BrowserHistory;
+
+  declare export type MemoryHistory = {|
+    ...History<>,
+    index: number,
+    entries: Array<string | Location>,
+    canGo(n: number): boolean,
+  |};
+
+  declare type MemoryHistoryOpts = {|
+    initialEntries?: Array<string>,
+    initialIndex?: number,
+    keyLength?: number,
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+  |};
+
+  declare function createMemoryHistory(opts?: MemoryHistoryOpts): MemoryHistory;
+
+  declare export type HashLocation = {|
+    ...Location,
+    state: void,
+    key: void,
+  |};
+
+  declare export type HashHistory = History<HashLocation>;
+
+  declare type HashHistoryOpts = {|
+    basename?: string,
+    hashType: 'slash' | 'noslash' | 'hashbang',
+    getUserConfirmation?: (
+      message: string,
+      callback: (willContinue: boolean) => void
+    ) => void,
+  |};
+
+  declare function createHashHistory(opts?: HashHistoryOpts): HashHistory;
+
+  // PathUtils
+  declare function parsePath(path: string): Location;
+
+  declare function createPath(location: $Shape<Location>): string;
+
+  // LocationUtils
+  declare function locationsAreEqual(
+    a: $Shape<Location>,
+    b: $Shape<Location>
+  ): boolean;
+
+  declare function createLocation(
+    path: string | $Shape<Location>,
+    state?: { ... },
+    key?: string,
+    currentLocation?: Location
+  ): Location;
+}
diff --git a/definitions/npm/history_v4.x.x/flow_v0.201.x-/test_history_v4.x.x.js b/definitions/npm/history_v4.x.x/flow_v0.201.x-/test_history_v4.x.x.js
new file mode 100644
index 0000000000..944f84f784
--- /dev/null
+++ b/definitions/npm/history_v4.x.x/flow_v0.201.x-/test_history_v4.x.x.js
@@ -0,0 +1,333 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+
+import {
+  createBrowserHistory,
+  createMemoryHistory,
+  createHashHistory,
+  createPath,
+  parsePath,
+  locationsAreEqual,
+  createLocation,
+} from 'history';
+
+// browser history
+
+describe('browser history', () => {
+  it('should allow to get location fields', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+      keyLength: 6,
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+      keyLength: 6,
+    });
+
+    const key: string = history.location.key;
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+      keyLength: 6,
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+        keyLength: 6,
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+        keyLength: 6,
+      });
+
+      history.push({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+        keyLength: 6,
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+        keyLength: 6,
+      });
+
+      history.replace({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+});
+
+describe('memory history', () => {
+  it('should allow to get location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+      keyLength: 6,
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+      keyLength: 6,
+    });
+
+    const key: string = history.location.key;
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+      keyLength: 6,
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+        keyLength: 6,
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+        keyLength: 6,
+      });
+
+      history.push({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+        keyLength: 6,
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+        keyLength: 6,
+      });
+
+      history.replace({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+});
+
+describe('hash history', () => {
+  it('should allow to get location fields', () => {
+    const history = createHashHistory({
+      basename: '',
+      hashType: 'slash',
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should not allow to get browser and memory specific location fields', () => {
+    const history = createHashHistory({
+      basename: '',
+      hashType: 'slash',
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const key: string = history.location.key;
+    // $FlowExpectedError[incompatible-type]
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createHashHistory({
+      basename: '',
+      hashType: 'slash',
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+        hashType: 'slash',
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+        hashType: 'slash',
+      });
+
+      history.push({
+        search: '?a=1',
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+        hashType: 'slash',
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+        hashType: 'slash',
+      });
+
+      history.push({
+        search: '?a=1',
+      });
+    });
+  });
+});
+
+describe('create path', () => {
+  it('should allow to use Location argument', () => {
+    const path = createPath({
+      pathname: '/test',
+      search: '?a=1',
+      hash: 'slug',
+    });
+
+    const key: string = path;
+    // $FlowExpectedError[incompatible-type]
+    const state: { ... } = path;
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-shape]
+    const path = createPath();
+
+    const key: string = path;
+  });
+});
+
+describe('parse path', () => {
+  it('should allow to use string argument', () => {
+    const location = parsePath('/test?query#hash');
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-call]
+    const location = parsePath();
+
+    const state: { ... } = location;
+  });
+});
+
+describe('create location', () => {
+  it('should allow to use string argument', () => {
+    const location = createLocation('/test?query#hash');
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+
+  it('should allow to use partial location as first argument', () => {
+    const location = createLocation({
+      pathname: '/test',
+      search: '?a=1',
+      hash: 'slug',
+    });
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+});
+
+describe('locations are equal', () => {
+  it('should allow to use partial location as arguments and return boolean', () => {
+    const isEqual = locationsAreEqual(
+      { pathname: '/test' },
+      { pathname: '/test', search: '?a=1' }
+    );
+
+    const bool: boolean = isEqual;
+    // $FlowExpectedError[incompatible-type]
+    const str: string = isEqual;
+  });
+});
diff --git a/definitions/npm/history_v5.x.x/flow_v0.104.x-/history_v5.x.x.js b/definitions/npm/history_v5.x.x/flow_v0.104.x-v0.200.x/history_v5.x.x.js
similarity index 100%
rename from definitions/npm/history_v5.x.x/flow_v0.104.x-/history_v5.x.x.js
rename to definitions/npm/history_v5.x.x/flow_v0.104.x-v0.200.x/history_v5.x.x.js
diff --git a/definitions/npm/history_v5.x.x/flow_v0.104.x-/test_history_v5.x.x.js b/definitions/npm/history_v5.x.x/flow_v0.104.x-v0.200.x/test_history_v5.x.x.js
similarity index 100%
rename from definitions/npm/history_v5.x.x/flow_v0.104.x-/test_history_v5.x.x.js
rename to definitions/npm/history_v5.x.x/flow_v0.104.x-v0.200.x/test_history_v5.x.x.js
diff --git a/definitions/npm/history_v5.x.x/flow_v0.201.x-/history_v5.x.x.js b/definitions/npm/history_v5.x.x/flow_v0.201.x-/history_v5.x.x.js
new file mode 100644
index 0000000000..dd5fe4a75c
--- /dev/null
+++ b/definitions/npm/history_v5.x.x/flow_v0.201.x-/history_v5.x.x.js
@@ -0,0 +1,92 @@
+declare module 'history' {
+  declare type Unregister = () => void;
+
+  declare export type Action = 'PUSH' | 'REPLACE' | 'POP';
+
+  declare export type Location = {|
+    pathname: string,
+    search: string,
+    hash: string,
+    state: { ... },
+    key: string,
+  |};
+
+  declare type History<HistoryLocation = Location> = {|
+    length: number,
+    location: HistoryLocation,
+    action: Action,
+    push: ((path: string, state?: { ... }) => void) &
+      ((location: $Shape<HistoryLocation>) => void),
+    replace: ((path: string, state?: { ... }) => void) &
+      ((location: $Shape<HistoryLocation>) => void),
+    go(n: number): void,
+    back(): void,
+    forward(): void,
+    listen(({| location: HistoryLocation, action: Action |}) => void): Unregister,
+    block(
+      blocker: (transition: {|
+        action: Action,
+        location: HistoryLocation,
+        retry: () => void,
+      |}) => void,
+    ): Unregister,
+    createHref(location: $Shape<HistoryLocation>): string,
+  |};
+
+  declare export type BrowserHistory = History<>;
+
+  declare type BrowserHistoryOpts = {|
+    basename?: string,
+    forceRefresh?: boolean,
+  |};
+
+  declare function createBrowserHistory(
+    opts?: BrowserHistoryOpts
+  ): BrowserHistory;
+
+  declare export type MemoryHistory = {|
+    ...History<>,
+    index: number,
+    entries: Array<string | Location>,
+    canGo(n: number): boolean,
+  |};
+
+  declare type MemoryHistoryOpts = {|
+    initialEntries?: Array<string>,
+    initialIndex?: number,
+  |};
+
+  declare function createMemoryHistory(opts?: MemoryHistoryOpts): MemoryHistory;
+
+  declare export type HashLocation = {|
+    ...Location,
+    state: void,
+    key: void,
+  |};
+
+  declare export type HashHistory = History<HashLocation>;
+
+  declare type HashHistoryOpts = {|
+    basename?: string,
+  |};
+
+  declare function createHashHistory(opts?: HashHistoryOpts): HashHistory;
+
+  // PathUtils
+  declare function parsePath(path: string): Location;
+
+  declare function createPath(location: $Shape<Location>): string;
+
+  // LocationUtils
+  declare function locationsAreEqual(
+    a: $Shape<Location>,
+    b: $Shape<Location>
+  ): boolean;
+
+  declare function createLocation(
+    path: string | $Shape<Location>,
+    state?: { ... },
+    key?: string,
+    currentLocation?: Location
+  ): Location;
+}
diff --git a/definitions/npm/history_v5.x.x/flow_v0.201.x-/test_history_v5.x.x.js b/definitions/npm/history_v5.x.x/flow_v0.201.x-/test_history_v5.x.x.js
new file mode 100644
index 0000000000..64d471dedc
--- /dev/null
+++ b/definitions/npm/history_v5.x.x/flow_v0.201.x-/test_history_v5.x.x.js
@@ -0,0 +1,343 @@
+// @flow
+import { describe, it } from 'flow-typed-test';
+
+import {
+  createBrowserHistory,
+  createMemoryHistory,
+  createHashHistory,
+  createPath,
+  parsePath,
+  locationsAreEqual,
+  createLocation,
+  type Action,
+  type Location,
+} from 'history';
+
+// browser history
+
+describe('browser history', () => {
+  it('should allow to get location fields', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+    });
+
+    const key: string = history.location.key;
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createBrowserHistory({
+      basename: '',
+      forceRefresh: false,
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+      });
+
+      history.push({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createBrowserHistory({
+        basename: '',
+        forceRefresh: false,
+      });
+
+      history.replace({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+});
+
+describe('memory history', () => {
+  it('should allow to get location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should allow to get browser and memory specific location fields', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+    });
+
+    const key: string = history.location.key;
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createMemoryHistory({
+      initialEntries: ['/'],
+      initialIndex: 0,
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+      });
+
+      history.push({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createMemoryHistory({
+        initialEntries: ['/'],
+        initialIndex: 0,
+      });
+
+      history.replace({
+        pathname: '/',
+        state: { a: 1 },
+      });
+    });
+  });
+});
+
+describe('hash history', () => {
+  it('should allow to get location fields', () => {
+    const history = createHashHistory({
+      basename: '',
+    });
+
+    const pathname: string = history.location.pathname;
+  });
+
+  it('should not allow to get browser and memory specific location fields', () => {
+    const history = createHashHistory({
+      basename: '',
+    });
+
+    // $FlowExpectedError[incompatible-type]
+    const key: string = history.location.key;
+    // $FlowExpectedError[incompatible-type]
+    const state: { ... } = history.location.state;
+  });
+
+  it('should not allow to get field which is absent in the history', () => {
+    const history = createHashHistory({
+      basename: '',
+    });
+
+    // $FlowExpectedError[prop-missing]
+    history.foo;
+  });
+
+  describe('#push', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+      });
+
+      history.push('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+      });
+
+      history.push({
+        search: '?a=1',
+      });
+    });
+  });
+
+  describe('#replace', () => {
+    it('should allow to use string as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+      });
+
+      history.replace('/');
+    });
+
+    it('should allow to use partial location as first argument', () => {
+      const history = createHashHistory({
+        basename: '',
+      });
+
+      history.push({
+        search: '?a=1',
+      });
+    });
+  });
+});
+
+describe('create path', () => {
+  it('should allow to use Location argument', () => {
+    const path = createPath({
+      pathname: '/test',
+      search: '?a=1',
+      hash: 'slug',
+    });
+
+    const key: string = path;
+    // $FlowExpectedError[incompatible-type]
+    const state: { ... } = path;
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-shape]
+    const path = createPath();
+
+    const key: string = path;
+  });
+});
+
+describe('parse path', () => {
+  it('should allow to use string argument', () => {
+    const location = parsePath('/test?query#hash');
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+
+  it('should not allow to accept void', () => {
+    // $FlowExpectedError[incompatible-call]
+    const location = parsePath();
+
+    const state: { ... } = location;
+  });
+});
+
+describe('create location', () => {
+  it('should allow to use string argument', () => {
+    const location = createLocation('/test?query#hash');
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+
+  it('should allow to use partial location as first argument', () => {
+    const location = createLocation({
+      pathname: '/test',
+      search: '?a=1',
+      hash: 'slug',
+    });
+
+    const state: { ... } = location;
+    // $FlowExpectedError[incompatible-type]
+    const key: string = location;
+  });
+});
+
+describe('locations are equal', () => {
+  it('should allow to use partial location as arguments and return boolean', () => {
+    const isEqual = locationsAreEqual(
+      { pathname: '/test' },
+      { pathname: '/test', search: '?a=1' }
+    );
+
+    const bool: boolean = isEqual;
+    // $FlowExpectedError[incompatible-type]
+    const str: string = isEqual;
+  });
+});
+
+describe('block api', () => {
+  const history = createBrowserHistory({
+    basename: '',
+  });
+
+  it('returns a callable function', () => {
+    const unregister = history.block(() => {});
+    unregister();
+
+    // $FlowExpectedError[extra-arg] accepts no args
+    unregister('test')
+  });
+
+  it('passes correct values into blocker', () => {
+    const unregister = history.block((({ action, location, retry }) => {
+      (action: Action);
+      (location: Location);
+
+      retry();
+      // $FlowExpectedError[extra-arg] accepts no args
+      retry('test');
+    }));
+  });
+
+  it('blocker must be provided', () => {
+    // $FlowExpectedError[incompatible-call]
+    const unregister = history.block();
+  });
+});
diff --git a/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-/hoist-non-react-statics_v2.x.x.js b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-v0.200.x/hoist-non-react-statics_v2.x.x.js
similarity index 100%
rename from definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-/hoist-non-react-statics_v2.x.x.js
rename to definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-v0.200.x/hoist-non-react-statics_v2.x.x.js
diff --git a/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-/test_hoist-non-react-statics_v2.x.x.js b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-v0.200.x/test_hoist-non-react-statics_v2.x.x.js
similarity index 100%
rename from definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-/test_hoist-non-react-statics_v2.x.x.js
rename to definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.104.x-v0.200.x/test_hoist-non-react-statics_v2.x.x.js
diff --git a/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/hoist-non-react-statics_v2.x.x.js b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/hoist-non-react-statics_v2.x.x.js
new file mode 100644
index 0000000000..e8078536df
--- /dev/null
+++ b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/hoist-non-react-statics_v2.x.x.js
@@ -0,0 +1,12 @@
+declare module 'hoist-non-react-statics' {
+  /*
+    S - source component statics
+    TP - target component props
+    SP - additional source component props
+  */
+  declare module.exports: <TP, SP, S>(
+    target: React$ComponentType<TP>,
+    source: React$ComponentType<SP> & S,
+    blacklist?: { [key: $Keys<S>]: boolean, ... }
+  ) => React$ComponentType<TP> & $Shape<S>;
+}
diff --git a/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/test_hoist-non-react-statics_v2.x.x.js b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/test_hoist-non-react-statics_v2.x.x.js
new file mode 100644
index 0000000000..7fdf66e257
--- /dev/null
+++ b/definitions/npm/hoist-non-react-statics_v2.x.x/flow_v0.201.x-/test_hoist-non-react-statics_v2.x.x.js
@@ -0,0 +1,50 @@
+// @flow
+
+import React from 'react';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+
+// $FlowExpectedError
+hoistNonReactStatics(1);
+// $FlowExpectedError
+hoistNonReactStatics(1, 2);
+// $FlowExpectedError
+hoistNonReactStatics(1, 2, 3);
+
+let C1 = (props: {
+  a: number,
+  b: string,
+  ...
+}) =>
+  <div>
+    {props.a} {props.b}
+  </div>;
+
+const C2 = (props: {
+  a: number,
+  b: string,
+  c: boolean,
+  ...
+}) =>
+  <div>
+    {props.a} {props.b} {props.c}
+  </div>;
+C2.foo = 1;
+C2.bar = 2;
+
+C1 = hoistNonReactStatics(C1, C2, { foo: true });
+C1.bar;
+
+class A extends React.Component<{a: number, ...}> {
+  static foo() { return 123; }
+}
+
+class B extends React.Component<{b: string, ...}> {
+  render() { return <A a={1} />; }
+}
+
+const C = hoistNonReactStatics(B, A);
+
+A.foo();
+// $FlowExpectedError
+B.foo();
+C.foo();
diff --git a/definitions/npm/idb_v5.x.x/flow_v0.83.x-/idb_v5.x.x.js b/definitions/npm/idb_v5.x.x/flow_v0.201.x-/idb_v5.x.x.js
similarity index 100%
rename from definitions/npm/idb_v5.x.x/flow_v0.83.x-/idb_v5.x.x.js
rename to definitions/npm/idb_v5.x.x/flow_v0.201.x-/idb_v5.x.x.js
diff --git a/definitions/npm/idb_v5.x.x/flow_v0.83.x-v0.200.x/idb_v5.x.x.js b/definitions/npm/idb_v5.x.x/flow_v0.83.x-v0.200.x/idb_v5.x.x.js
new file mode 100644
index 0000000000..79939d71ec
--- /dev/null
+++ b/definitions/npm/idb_v5.x.x/flow_v0.83.x-v0.200.x/idb_v5.x.x.js
@@ -0,0 +1,643 @@
+// Derived from TS typings at https://github.com/jakearchibald/idb/blob/c8bab898f01bacab96097f87c1e42a0c19e01425/lib/idb.d.ts
+// Updated for changes between v2 and v5.
+
+declare type $idb$IDBArrayKey = $ReadOnlyArray<$idb$IDBValidKey>;
+declare type $idb$IDBValidKey = number | string | Date | $idb$IDBArrayKey;
+
+// TODO: upstream this to Flow DOM definitions
+declare class $idb$DOMStringList {
+  +length: number;
+  // Comment syntax here as @@iterator is invalid syntax for eslint and babylon
+  /*:: @@iterator(): Iterator<string>; */
+  contains(str: string): boolean;
+  item(index: number): string | null;
+  [index: number]: string;
+  @@iterator(): Iterator<string>;
+}
+
+/** Similar to equivalent IDBDatabase. */
+declare class $idb$DB<ObjectStore: $idb$ObjectStore<any, any>> {
+  /** A DOMString that contains the name of the connected database. */
+  +name: string;
+
+  /** A 64-bit integer that contains the version of the connected database. When a database is first created, this attribute is an empty string. */
+  +version: number;
+
+  /** A DOMStringList that contains a list of the names of the object stores currently in the connected database. */
+  +objectStoreNames: $idb$DOMStringList;
+
+  /** Returns immediately and closes the connection to a database in a separate thread. */
+  close(): void;
+
+  /**
+   * Creates and returns a new object store or index.
+   * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
+   * @param name The name of the new object store to be created. Note that it is possible to create an object store with an empty name.
+   * @param optionalParameters Optional. An options object whose attributes are optional parameters to the method.
+   * @returns The new object store.
+   */
+  createObjectStore(
+    name: string,
+    optionalParameters?: $Shape<{|
+     +keyPath: string,
+     +autoIncrement: boolean,
+    |}>
+  ): ObjectStore;
+
+  /**
+   * Destroys the object store with the given name in the connected database, along with any indexes that reference it.
+   * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
+   * @param name The name of the object store to be removed.
+   */
+  deleteObjectStore(name: string): void;
+
+  /**
+   * Immediately returns a transaction object (Transaction) containing the IDBTransaction.objectStore method, which you can use to access your object store. Runs in a separate thread.
+   * @param storeNames The names of object stores and indexes that are in the scope of the new transaction, declared as an array of strings. Specify only the object stores that you need to access.
+   * If you need to access only one object store, you can specify its name as a string.
+   * @param mode Optional. The types of access that can be performed in the transaction. Transactions are opened in one of three modes: 'readonly' or 'readwrite'. 'versionchange' mode can't be specified here. If you don't provide the parameter, the default access mode is readonly. To avoid slowing things down, don't open a readwrite transaction unless you actually need to write into the database.
+   * @returns The transaction object.
+   */
+  transaction(
+    storeNames: string,
+    mode?: 'readonly' | 'readwrite'
+  ): $idb$Transaction<ObjectStore, ObjectStore>;
+  transaction(
+    storeNames: Array<string>,
+    mode?: 'readonly' | 'readwrite'
+  ): $idb$Transaction<ObjectStore, null>;
+
+  /*---
+   * These are the objectstore shortcuts: they're the same prototypes of the
+   * functions in ObjectStore except they also take the store name as first
+   * parameter.
+   *--- */
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) creates a structured clone of the value, and updates the cloned value in the object store.
+   * This is for updating existing records in an object store when the transaction's mode is readwrite.
+   * @param storeName the store to use.
+   * @param value The value to be stored.
+   * @param key Optional. The key to use to identify the record. If unspecified, it results to null.
+   * @returns A promise that resolves with the new key when the underlying put IDBRequest is successful.
+   */
+  put(storeName: string, value: mixed, key?: $idb$IDBValidKey): Promise<$idb$IDBValidKey>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) creates a structured clone of the value, and stores the cloned value in the object store.
+   * This is for adding new records to an object store.
+   * @param storeName the store to use.
+   * @param value The value to be stored.
+   * @param key Optional. The key to use to identify the record. If unspecified, it results to null.
+   * @returns A promise that resolves with the new key when the underlying add IDBRequest is successful.
+   */
+  add(storeName: string, value: mixed, key?: $idb$IDBValidKey): Promise<$idb$IDBValidKey>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) deletes the store object specified.
+   * This is for deleting individual records out of an object store.
+   * @param storeName the store to use.
+   * @param key The key of the record to be deleted, or an IDBKeyRange to delete all records with keys in range.
+   * @returns A promise that resolves when the underlying delete IDBRequest is successful.
+   */
+  delete(storeName: string, key: IDBKeyRange | $idb$IDBValidKey): Promise<void>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) clears the object store.
+   * This is for deleting all current records out of an object store.
+   * @param storeName the store to use.
+   * @returns A promise that resolves when the underlying clear IDBRequest is successful.
+   */
+  clear(storeName: string): Promise<void>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the store object store selected by the specified key.
+   * This is for retrieving specific records from an object store.
+   * @param storeName the store to use.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  get(storeName: string, key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
+   * @param storeName the store to use.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the items when the underlying getAll IDBRequest is successful.
+   */
+  getAll(
+    storeName: string,
+    query?: IDBKeyRange | $idb$IDBValidKey,
+    count?: number
+  ): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) finds either the given key or the primary key, if key is an IDBKeyRange.
+   * @param storeName the store to use.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  getKey(storeName: string, key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with record keys for all the objects matching the specified parameter or all record keys in the store if no parameters are given.
+   * @param storeName the store to use.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the record keys when the underlying getAllKeys IDBRequest is successful.
+   */
+  getAllKeys(storeName: string, query?: IDBKeyRange, count?: number): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) counts the matching records.
+   * If no arguments are provided, it returns the total number of records in the store.
+   * @param storeName the store to use.
+   * @param key A key or IDBKeyRange object that specifies a range of records you want to count.
+   * @returns A promise that resolves with the total when the underlying count IDBRequest is successful.
+   */
+  count(storeName: string, key?: IDBKeyRange | $idb$IDBValidKey): Promise<number>;
+
+  /*---
+   * These are the index shortcuts: they're the same prototypes of the
+   * functions in Index except they also take the store and index names as
+   * first parameters.
+   *--- */
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) counts the matching records.
+   * If no arguments are provided, it returns the total number of records in the store.
+   * @param storeName the store to use.
+   * @param indexName the index to use.
+   * @param key A key or IDBKeyRange object that specifies a range of records you want to count.
+   * @returns A promise that resolves with the total when the underlying count IDBRequest is successful.
+   */
+  countFromIndex(storeName: string, indexName: string, key?: IDBKeyRange | $idb$IDBValidKey): Promise<number>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the store object store selected by the specified key.
+   * This is for retrieving specific records from an object store.
+   * @param storeName the store to use.
+   * @param indexName the index to use.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  getFromIndex(storeName: string, indexName: string, key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) finds either the given key or the primary key, if key is an IDBKeyRange.
+   * @param storeName the store to use.
+   * @param indexName the index to use.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  getKeyFromIndex(storeName: string, indexName: string, key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
+   * @param storeName the store to use.
+   * @param indexName the index to use.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the items when the underlying getAll IDBRequest is successful.
+   */
+  getAllFromIndex(
+    storeName: string,
+    indexName: string,
+    query?: IDBKeyRange | $idb$IDBValidKey,
+    count?: number
+  ): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with record keys for all the objects matching the specified parameter or all record keys in the store if no parameters are given.
+   * @param storeName the store to use.
+   * @param indexName the index to use.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the record keys when the underlying getAllKeys IDBRequest is successful.
+   */
+  getAllKeysFromIndex(storeName: string, indexName: string, query?: IDBKeyRange, count?: number): Promise<Array<any>>;
+}
+
+type $idb$OpenDBCallbacks<ObjectStore: $idb$ObjectStore<any, any>> = {|
+  /**
+   * Called if this version of the database has never been opened before. Use it to specify the
+   * schema for the database.
+   *
+   * @param database A database instance that you can use to add/remove stores and indexes.
+   * @param oldVersion Last version of the database opened by the user.
+   * @param newVersion Whatever new version you provided.
+   * @param transaction The transaction for this upgrade. This is useful if you need to get data
+   * from other stores as part of a migration.
+   */
+  upgrade(
+    database: $idb$DB<ObjectStore>,
+    oldVersion: number,
+    newVersion: number | null,
+    transaction: $idb$Transaction<ObjectStore, null>
+  ): void,
+  /**
+   * Called if there are older versions of the database open on the origin, so this version cannot
+   * open.
+   */
+  blocked(): void,
+  /**
+   * Called if this connection is blocking a future version of the database from opening.
+   */
+  blocking(): void,
+  /**
+   * Called if the browser abnormally terminates the connection.
+   * This is not called when `db.close()` is called.
+   */
+  terminated(): void,
+|};
+
+/** Wrapper of IDBTransaction that presents the asynchronous operations as a Promise. */
+declare class $idb$Transaction<ObjectStore: $idb$ObjectStore<any, any>, StoreType: ObjectStore | null> {
+  /** Resolves when transaction completes, rejects if transaction aborts or errors. */
+  +done: Promise<void>;
+  +store: StoreType;
+
+  /** Returns a DOMStringList of the names of IDBObjectStore objects. */
+  +objectStoreNames: $idb$DOMStringList;
+
+  /** The mode for isolating access to data in the object stores that are in the scope of the transaction. For possible values, see the Constants section below. The default value is readonly. */
+  +mode: 'readonly' | 'readwrite' | 'versionchange';
+
+  /** Rolls back all the changes to objects in the database associated with this transaction. If this transaction has been aborted or completed, then this method throws an error event. */
+  abort(): void;
+
+  /**
+   * Returns an ObjectStore object representing an object store that is part of the scope of this transaction.
+   * @param name The name of the requested object store.
+   * @returns The object store in the context of the transaction.
+   */
+  objectStore(name: string): ObjectStore;
+}
+
+/** Common interface for ObjectStore and Index, since both provide these cursor methods */
+declare class $idb$HasCursor<Cursor: $idb$Cursor> {
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves a new cursor object.
+   * Used for iterating through an object store by primary key with a cursor.
+   * @param range Optional. A key or IDBKeyRange to be queried. If a single valid key is passed, this will default to a range containing only that key. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param direction Optional. An IDBCursorDirection² telling the cursor what direction to travel. Defaults to "next".
+   * @returns A promise that resolves with the cursor once it has been opened.
+   */
+  openCursor(
+    range?: IDBKeyRange | $idb$IDBValidKey | null,
+    direction?: 'next' | 'nextunique' | 'prev' | 'prevunique'
+  ): Promise<Cursor>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves a new cursor object.
+   * Used for iterating through an object store with a key.
+   * @param range Optional. A key or IDBKeyRange to be queried. If a single valid key is passed, this will default to a range containing only that key. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param direction Optional. An IDBCursorDirection telling the cursor what direction to travel. Defaults to "next".
+   * @returns A promise that resolves with the cursor once it has been opened.
+   */
+  openKeyCursor(
+    range?: IDBKeyRange | $idb$IDBValidKey | null,
+    direction?: 'next' | 'nextunique' | 'prev' | 'prevunique'
+  ): Promise<Cursor>;
+}
+
+/** Wrapper of IDBObjectStore that presents the asynchronous operations as Promises. */
+declare class $idb$ObjectStore<Cursor: $idb$Cursor, Index: $idb$Index<Cursor>> extends $idb$HasCursor<Cursor> {
+  /** The name of this object store. Settable only during upgrades. */
+  name: string;
+
+  /** The key path of this object store. If this attribute is null, the application must provide a key for each modification operation. */
+  +keyPath: string | Array<string>;
+
+  /** A list of the names of indexes on objects in this object store. */
+  +indexNames: $idb$DOMStringList;
+
+  /** The value of the auto increment flag for this object store. */
+  +autoIncrement: boolean;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) creates a structured clone of the value, and updates the cloned value in the object store.
+   * This is for updating existing records in an object store when the transaction's mode is readwrite.
+   * @param value The value to be stored.
+   * @param key Optional. The key to use to identify the record. If unspecified, it results to null.
+   * @returns A promise that resolves with the new key when the underlying put IDBRequest is successful.
+   */
+  put(value: mixed, key?: $idb$IDBValidKey): Promise<$idb$IDBValidKey>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) creates a structured clone of the value, and stores the cloned value in the object store.
+   * This is for adding new records to an object store.
+   * @param value The value to be stored.
+   * @param key Optional. The key to use to identify the record. If unspecified, it results to null.
+   * @returns A promise that resolves with the new key when the underlying add IDBRequest is successful.
+   */
+  add(value: mixed, key?: $idb$IDBValidKey): Promise<$idb$IDBValidKey>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) deletes the store object specified.
+   * This is for deleting individual records out of an object store.
+   * @param key The key of the record to be deleted, or an IDBKeyRange to delete all records with keys in range.
+   * @returns A promise that resolves when the underlying delete IDBRequest is successful.
+   */
+  delete(key: IDBKeyRange | $idb$IDBValidKey): Promise<void>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) clears the object store.
+   * This is for deleting all current records out of an object store.
+   * @returns A promise that resolves when the underlying clear IDBRequest is successful.
+   */
+  clear(): Promise<void>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the store object store selected by the specified key.
+   * This is for retrieving specific records from an object store.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  get(key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the items when the underlying getAll IDBRequest is successful.
+   */
+  getAll(
+    query?: IDBKeyRange | $idb$IDBValidKey,
+    count?: number
+  ): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) finds either the given key or the primary key, if key is an IDBKeyRange.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  getKey(key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with record keys for all the objects matching the specified parameter or all record keys in the store if no parameters are given.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the record keys when the underlying getAllKeys IDBRequest is successful.
+   */
+  getAllKeys(query?: IDBKeyRange, count?: number): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) counts the matching records.
+   * If no arguments are provided, it returns the total number of records in the store.
+   * @param key A key or IDBKeyRange object that specifies a range of records you want to count.
+   * @returns A promise that resolves with the total when the underlying count IDBRequest is successful.
+   */
+  count(key?: IDBKeyRange | $idb$IDBValidKey): Promise<number>;
+
+  /**
+   * Creates a new index during a version upgrade, returning a new Index object in the connected database.
+   * @param name The name of the index to create. It is possible to create an index with an empty name.
+   * @param keyPath The key path for the index to use. It is possible to create an index with an empty keyPath, and also to pass in an array as a keyPath.
+   * @param optionalParameters Additional options: unique and multiEntry.
+   * @returns The newly created index.
+   */
+  createIndex(
+    name: string,
+    keyPath: string | Array<string>,
+    optionalParameters?: $Shape<{|
+     +unique: boolean,
+     +multiEntry: boolean,
+     +locale: string | 'auto' | null,
+    |}>
+  ): Index;
+
+  /**
+   * Destroys the specified index in the connected database, used during a version upgrade.
+   * @param indexName The name of the existing index to remove.
+   */
+  deleteIndex(indexName: string): void;
+
+  /**
+   * Opens an index from this object store after which it can, for example, be used to return a sequence of records sorted by that index using a cursor.
+   * @param name The name of the existing index to get.
+   * @returns The specified index.
+   */
+  index(name: string): Index;
+}
+
+/** Wrapper of IDBIndex that presents the asynchronous operations as Promises. */
+declare class $idb$Index<Cursor: $idb$Cursor> extends $idb$HasCursor<Cursor> {
+  /** The name of this index. */
+  +name: string;
+
+  /** The key path of this index. If null, this index is not auto-populated. */
+  +keyPath: string | Array<string>;
+
+  /**
+   * Affects how the index behaves when the result of evaluating the index's key path yields an array.
+   * If true, there is one record in the index for each item in an array of keys.
+   * If false, then there is one record for each key that is an array.
+   */
+  +multiEntry: boolean;
+
+  /** If true, this index does not allow duplicate values for a key. */
+  +unique: boolean;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) counts the matching records.
+   * If no arguments are provided, it returns the total number of records in the store.
+   * @param key A key or IDBKeyRange object that specifies a range of records you want to count.
+   * @returns A promise that resolves with the total when the underlying count IDBRequest is successful.
+   */
+  count(key?: IDBKeyRange | $idb$IDBValidKey): Promise<number>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the store object store selected by the specified key.
+   * This is for retrieving specific records from an object store.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  get(key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) finds either the given key or the primary key, if key is an IDBKeyRange.
+   * @param key The key or key range that identifies the record to be retrieved.
+   * @returns A promise that resolves with the item when the underlying get IDBRequest is successful.
+   */
+  getKey(key: IDBKeyRange | $idb$IDBValidKey): Promise<any>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with the objects in the object store matching the specified parameter or all objects in the store if no parameters are given.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the items when the underlying getAll IDBRequest is successful.
+   */
+  getAll(
+    query?: IDBKeyRange | $idb$IDBValidKey,
+    count?: number
+  ): Promise<Array<any>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) resolves with record keys for all the objects matching the specified parameter or all record keys in the store if no parameters are given.
+   * @param query Optional. A key or IDBKeyRange to be queried. If nothing is passed, this will default to a key range that selects all the records in this object store.
+   * @param count Optional. Specifies the number of values to return if more than one is found. If it is lower than 0 or greater than 232-1 a TypeError exception will be thrown.
+   * @returns A promise that resolves with the record keys when the underlying getAllKeys IDBRequest is successful.
+   */
+  getAllKeys(query?: IDBKeyRange, count?: number): Promise<Array<any>>;
+}
+
+/** Wrapper of IDBCursor that presents the asynchronous operations as Promises. */
+declare class $idb$Cursor {
+  /** The key for the record at the cursor's position. If the cursor is outside its range, this is set to undefined. The cursor's key can be any data type. */
+  +key: IDBKeyRange | $idb$IDBValidKey;
+
+  /** The cursor's current effective primary key. If the cursor is currently being iterated or has iterated outside its range, this is set to undefined. The cursor's primary key can be any data type. */
+  +primaryKey: any;
+
+  /** The direction of traversal of the cursor. */
+  +direction: 'next' | 'nextunique' | 'prev' | 'prevunique';
+
+  /** The current value under the cursor. */
+  +value: any;
+
+  /** Returns the IDBObjectStore or IDBIndex the cursor was opened from. */
+  +source: $idb$Index<Class<this>> | $idb$ObjectStore<Class<this>, $idb$Index<Class<this>>>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) deletes the record at the cursor's position, without changing the cursor's position.
+   * This can be used to delete specific records.
+   * @returns A promise that resolves when the underlying delete IDBRequest is successful.
+   */
+  delete(): Promise<void>;
+
+  /**
+   * Returns a Promise of an IDBRequest object that (in a separate thread) updates the value at the current position of the cursor in the object store.
+   * This can be used to update specific records.
+   * @param value The value to write over the current cursor location.
+   * @returns A promise that resolves when the underlying update IDBRequest is successful.
+   */
+  update(value: any): Promise<void>;
+
+  /**
+   * Sets the number times a cursor should move its position forward.
+   * @param count The number of times to move the cursor forward.
+   * @returns The cursor after having been moved forward the specified number of times.
+   */
+  advance(count: number): Promise<this | null>;
+
+  /**
+   * Advances the cursor to the next position along its direction, to the item whose key matches the optional key parameter.
+   * @param key Optional. The key to position the cursor at. If no key is specified, the cursor advances to the immediate next position, based on the its direction.
+   * @returns The cursor after having been continued to the next or specified record.
+   */
+  continue(key?: IDBKeyRange | $idb$IDBValidKey): Promise<this | null>;
+
+  /**
+   * Sets the cursor to the given index key and primary key given as arguments.
+   * @param key The key to position the cursor at.
+   * @param primaryKey The primary key to position the cursor at.
+   * @returns The cursor after having been continued to the next or specified record.
+   */
+  continuePrimaryKey(
+    key: IDBKeyRange | $idb$IDBValidKey,
+    primaryKey: IDBKeyRange | $idb$IDBValidKey
+  ): Promise<this | null>;
+}
+
+declare module 'idb' {
+  declare export type ObjectStore = $idb$ObjectStore<Cursor, Index>;
+  declare export type DB = $idb$DB<ObjectStore>;
+  declare export type Index = $idb$Index<Cursor>;
+  declare export type Cursor = $idb$Cursor;
+  declare export type Transaction<T> = $idb$Transaction<ObjectStore, T>;
+
+  declare type OpenDBCallbacks = $idb$OpenDBCallbacks<ObjectStore>;
+
+  /**
+   * This method returns a promise that resolves to a DB.
+   * @param name The name of the database.
+   * @param version Optional. The version to open the database with. If the version is not provided and the database exists, then a connection to the database will be opened without changing its version. If the version is not provided and the database does not exist, then it will be created with version 1.
+   * @param upgradeCallback Optional. Called if version is greater than the version last opened. It's similar to IDB's onupgradeneeded. The callback receives an instance of UpgradeDB.
+   * @returns A Promise that passes the DB once it has been opened.
+   */
+  declare export function openDB(
+    name: string,
+    version: number,
+    options?: $Shape<OpenDBCallbacks>,
+  ): Promise<DB>;
+
+  /**
+   * Behaves like indexedDB.deleteDatabase, but returns a promise.
+   * @param name The name of the database.
+   * @returns A Promise that completes once the DB has been removed.
+   */
+  declare export function deleteDB(name: string): Promise<void>;
+
+  declare export var wrap: {|
+    (IDBDatabase): DB;
+    (IDBTransaction): Transaction<null>;
+    (IDBObjectStore): ObjectStore;
+    (IDBIndex): Index;
+    (IDBRequest): Promise<any>; // Unfortunately the default Flow types for IDB are severaly lacking, so we can't do better.
+  |};
+
+  declare export var unwrap: {|
+    (DB): IDBDatabase;
+    (Transaction<any>): IDBTransaction;
+    (ObjectStore): IDBObjectStore;
+    (Index): IDBIndex;
+    (Promise<any>): IDBRequest;
+  |};
+}
+
+declare module 'idb/with-async-ittr.js' {
+  declare class HasAsyncCursor {
+    @@asyncIterator(): AsyncIterator<Cursor>;
+    iterate(
+      range?: IDBKeyRange | $idb$IDBValidKey | null,
+      direction?: 'next' | 'nextunique' | 'prev' | 'prevunique'
+    ): AsyncIterable<Cursor>;
+  }
+
+  declare export class ObjectStore extends $idb$ObjectStore<Cursor, Index> mixins HasAsyncCursor {}
+  declare export class Index extends $idb$Index<Cursor> mixins HasAsyncCursor {}
+  declare export class Cursor extends $idb$Cursor {
+    @@asyncIterator(): AsyncIterator<Cursor>;
+  }
+
+  declare export type DB = $idb$DB<ObjectStore>;
+  declare export type Transaction<T> = $idb$Transaction<ObjectStore, T>;
+
+  declare type OpenDBCallbacks = $idb$OpenDBCallbacks<ObjectStore>;
+
+  /**
+   * This method returns a promise that resolves to a DB.
+   * @param name The name of the database.
+   * @param version Optional. The version to open the database with. If the version is not provided and the database exists, then a connection to the database will be opened without changing its version. If the version is not provided and the database does not exist, then it will be created with version 1.
+   * @param upgradeCallback Optional. Called if version is greater than the version last opened. It's similar to IDB's onupgradeneeded. The callback receives an instance of UpgradeDB.
+   * @returns A Promise that passes the DB once it has been opened.
+   */
+  declare export function openDB(
+    name: string,
+    version: number,
+    options?: $Shape<OpenDBCallbacks>,
+  ): Promise<DB>;
+
+  /**
+   * Behaves like indexedDB.deleteDatabase, but returns a promise.
+   * @param name The name of the database.
+   * @returns A Promise that completes once the DB has been removed.
+   */
+  declare export function deleteDB(name: string): Promise<void>;
+
+  declare export var wrap: {|
+    (IDBDatabase): DB;
+    (IDBTransaction): Transaction<null>;
+    (IDBObjectStore): ObjectStore;
+    (IDBIndex): Index;
+    (IDBRequest): Promise<any>; // Unfortunately the default Flow types for IDB are severaly lacking, so we can't do better.
+  |};
+
+  declare export var unwrap: {|
+    (DB): IDBDatabase;
+    (Transaction<any>): IDBTransaction;
+    (ObjectStore): IDBObjectStore;
+    (Index): IDBIndex;
+    (Promise<any>): IDBRequest;
+  |};
+}
diff --git a/definitions/npm/introscope_v1.0.10/flow_v0.104.x-/introscope_v1.0.10.js b/definitions/npm/introscope_v1.0.10/flow_v0.104.x-v0.200.x/introscope_v1.0.10.js
similarity index 100%
rename from definitions/npm/introscope_v1.0.10/flow_v0.104.x-/introscope_v1.0.10.js
rename to definitions/npm/introscope_v1.0.10/flow_v0.104.x-v0.200.x/introscope_v1.0.10.js
diff --git a/definitions/npm/introscope_v1.0.10/flow_v0.201.x-/introscope_v1.0.10.js b/definitions/npm/introscope_v1.0.10/flow_v0.201.x-/introscope_v1.0.10.js
new file mode 100644
index 0000000000..af4198850b
--- /dev/null
+++ b/definitions/npm/introscope_v1.0.10/flow_v0.201.x-/introscope_v1.0.10.js
@@ -0,0 +1,10 @@
+declare module 'introscope' {
+    // `introscope` is using any type on purpose,
+    // some developers require only part of their tests
+    // to have strict types.
+    // eslint-disable-next-line flowtype/no-weak-types
+    declare type AnyScope = { [string]: any, ... };
+    declare function introscope(scope: AnyScope): AnyScope => AnyScope;
+
+    declare function scope<Scope: {...}>(scope: Scope): ($Shape<Scope>) => Scope;
+}
diff --git a/definitions/npm/jsonwebtoken_v8.1.x/flow_v0.104.x-/jsonwebtoken_v8.1.x.js b/definitions/npm/jsonwebtoken_v8.1.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.1.x.js
similarity index 100%
rename from definitions/npm/jsonwebtoken_v8.1.x/flow_v0.104.x-/jsonwebtoken_v8.1.x.js
rename to definitions/npm/jsonwebtoken_v8.1.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.1.x.js
diff --git a/definitions/npm/jsonwebtoken_v8.1.x/flow_v0.201.x-/jsonwebtoken_v8.1.x.js b/definitions/npm/jsonwebtoken_v8.1.x/flow_v0.201.x-/jsonwebtoken_v8.1.x.js
new file mode 100644
index 0000000000..786abfaaad
--- /dev/null
+++ b/definitions/npm/jsonwebtoken_v8.1.x/flow_v0.201.x-/jsonwebtoken_v8.1.x.js
@@ -0,0 +1,122 @@
+declare module "jsonwebtoken" {
+  declare module.exports: {
+    sign: jwt$Sign,
+    decode: jwt$Decode,
+    verify: jwt$Verify,
+    JsonWebTokenError: Class<jwt$WebTokenError>,
+    NotBeforeError: Class<jwt$NotBeforeError>,
+    TokenExpiredError: Class<jwt$TokenExpiredError>,
+    ...
+  }
+}
+
+declare type jwt$Encodable = String | Buffer | Object;
+declare type jwt$Key = {
+  key: string | Buffer,
+  passphrase: string | Buffer,
+  ...
+};
+declare type jwt$Algorithm =
+  'RS256'
+  | 'RS384'
+  | 'RS512'
+  | 'ES256'
+  | 'ES384'
+  | 'ES512'
+  | 'HS256'
+  | 'HS384'
+  | 'HS512'
+  | 'none';
+
+declare type jwt$Callback = (tokenOrError: Error | string) => void;
+declare type jwt$SigningOptions<Headers> = $Shape<{
+  algorithm: jwt$Algorithm,
+  expiresIn: number | string,
+  notBefore: number | string,
+  audience: string | string[],
+  issuer: string,
+  jwtid: string,
+  subject: string,
+  noTimestamp: boolean,
+  header: Headers,
+  keyid: string,
+  ...
+}>;
+
+declare type jwt$SigningOptionsWithAlgorithm<H> = jwt$SigningOptions<H> & { algorithm: jwt$Algorithm, ... };
+declare type jwt$VerifyOptionsWithAlgorithm = jwt$VerifyOptions & { algorithms: Array<jwt$Algorithm>, ... };
+
+declare type jwt$VerifyOptions = $Shape<{
+  algorithms: Array<jwt$Algorithm>,
+  audience: string,
+  issuer: string | string[],
+  ignoreExpiration: boolean,
+  ignoreNotBefore: boolean,
+  subject: string | string[],
+  clockTolerance: number,
+  maxAge: string | number,
+  clockTimestamp: number,
+  ...
+}>;
+
+declare type jwt$DecodingOptions = $Shape<{
+  complete: boolean,
+  json: boolean,
+  encoding: string,
+  ...
+}>;
+
+declare interface jwt$Sign {
+  <P: jwt$Encodable>
+  (payload: P, secretOrPrivateKey: string | Buffer): string;
+
+  <P: jwt$Encodable>
+  (payload: P, secretOrPrivateKey: string | Buffer, callback: jwt$Callback): string;
+
+  <P: jwt$Encodable, H>
+  (payload: P, secretOrPrivateKey: jwt$Key, options: jwt$SigningOptionsWithAlgorithm<H>): string;
+
+  <P: jwt$Encodable, H>
+  (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<jwt$SigningOptions<H>>): string;
+
+  <P: jwt$Encodable, H>
+  (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<jwt$SigningOptions<H>>, callback: jwt$Callback): string;
+
+  <P: jwt$Encodable, H>
+  (payload: P, secretOrPrivateKey: jwt$Key, options: jwt$SigningOptionsWithAlgorithm<H>, callback: jwt$Callback): string;
+}
+
+declare interface jwt$Decode {
+  (jwt: string): mixed;
+
+  (jwt: string, options: jwt$DecodingOptions): mixed;
+
+  (jwt: string, options: jwt$DecodingOptions & { complete: true, ... }): {
+    header: Object,
+    payload: mixed,
+    signature: string,
+    ...
+  };
+}
+
+declare interface jwt$Verify {
+  (jwt: string, secretOrPrivateKey: string | Buffer): mixed;
+
+  (jwt: string, secretOrPrivateKey: string | Buffer, options: jwt$VerifyOptions | jwt$Callback): mixed;
+
+  (jwt: string, secretOrPrivateKey: string | Buffer, options: jwt$VerifyOptions, callback: jwt$Callback): mixed;
+
+  (jwt: string, secretOrPrivateKey: jwt$Key, options: jwt$VerifyOptionsWithAlgorithm): mixed;
+
+  (jwt: string, secretOrPrivateKey: jwt$Key, options: jwt$VerifyOptionsWithAlgorithm, callback: jwt$Callback): mixed;
+}
+
+declare class jwt$TokenExpiredError extends Error {
+}
+
+declare class jwt$WebTokenError extends Error {
+}
+
+declare class jwt$NotBeforeError extends Error {
+}
+
diff --git a/definitions/npm/jsonwebtoken_v8.2.x/flow_v0.104.x-/jsonwebtoken_v8.2.x.js b/definitions/npm/jsonwebtoken_v8.2.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.2.x.js
similarity index 100%
rename from definitions/npm/jsonwebtoken_v8.2.x/flow_v0.104.x-/jsonwebtoken_v8.2.x.js
rename to definitions/npm/jsonwebtoken_v8.2.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.2.x.js
diff --git a/definitions/npm/jsonwebtoken_v8.2.x/flow_v0.201.x-/jsonwebtoken_v8.2.x.js b/definitions/npm/jsonwebtoken_v8.2.x/flow_v0.201.x-/jsonwebtoken_v8.2.x.js
new file mode 100644
index 0000000000..c6e2d0ec44
--- /dev/null
+++ b/definitions/npm/jsonwebtoken_v8.2.x/flow_v0.201.x-/jsonwebtoken_v8.2.x.js
@@ -0,0 +1,157 @@
+declare module "jsonwebtoken" {
+
+  declare class JsonWebTokenError extends Error {
+    name: string;
+    message: string;
+    inner: Error;
+  }
+
+  declare class TokenExpiredError extends Error {
+    name: string;
+    expiredAt: number;
+    inner: Error;
+  }
+
+  declare class NotBeforeError extends Error {
+    name: string;
+    date: Date;
+    inner: Error;
+  }
+
+  declare type Encodable = String | Buffer | Object;
+  declare type Key = {
+    key: string | Buffer,
+    passphrase: string | Buffer,
+    ...
+  };
+  declare type Algorithm =
+    'RS256'
+    | 'RS384'
+    | 'RS512'
+    | 'ES256'
+    | 'ES384'
+    | 'ES512'
+    | 'HS256'
+    | 'HS384'
+    | 'HS512'
+    | 'none';
+
+  declare type SignCallback = (err: Error, token: string) => void;
+  declare type SigningOptions<Headers> = $Shape<{
+    algorithm: Algorithm,
+    expiresIn: number | string,
+    notBefore: number | string,
+    audience: string | string[],
+    issuer: string | string[],
+    jwtid: string,
+    subject: string,
+    noTimestamp: boolean,
+    header: Headers,
+    keyid: string,
+    ...
+  }>;
+
+  declare type SigningOptionsWithAlgorithm<H> = SigningOptions<H> & { algorithm: Algorithm, ... };
+
+  declare type VerifyCallback = (err: JsonWebTokenError | NotBeforeError | TokenExpiredError | null, decoded: Payload) => void;
+  declare type VerifyOptionsWithAlgorithm = VerifyOptions & { algorithms: Array<Algorithm>, ... };
+  declare type VerifyOptions = $Shape<{
+    algorithms: Array<Algorithm>,
+    audience: string | string[],
+    issuer: string | string[],
+    ignoreExpiration: boolean,
+    ignoreNotBefore: boolean,
+    subject: string | string[],
+    clockTolerance: number,
+    maxAge: string | number,
+    clockTimestamp: number,
+    ...
+  }>;
+
+  declare type DecodingOptions = $Shape<{
+    complete: boolean,
+    json: boolean,
+    ...
+  }>;
+
+  declare interface Sign {
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer): string;
+
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>, callback: SignCallback): string;
+  }
+
+  declare type Payload = Object & {
+    jti?: string,
+    iss?: string,
+    sub?: string,
+    aud?: string | string[],
+    exp?: number,
+    iat?: number,
+    nbf?: number,
+    ...
+  }
+
+  declare type Token = {
+    header: {
+      typ: 'JWT',
+      alg: Algorithm,
+      ...
+    },
+    payload: Payload,
+    signature?: string,
+    ...
+  }
+
+  declare interface Decode {
+    (jwt: string): Payload;
+
+    (jwt: string, options: DecodingOptions): Payload;
+
+    (jwt: string, options: DecodingOptions & { complete: true, ... }): Token;
+  }
+
+  declare interface Verify {
+    (jwt: string, secretOrPrivateKey: string | Buffer): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions | VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions, callback: VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+  }
+
+  declare class TokenExpiredError extends Error {
+  }
+
+  declare class WebTokenError extends Error {
+  }
+
+  declare class NotBeforeError extends Error {
+  }
+
+  declare module.exports: {
+    sign: Sign,
+    decode: Decode,
+    verify: Verify,
+    JsonWebTokenError: Class<WebTokenError>,
+    NotBeforeError: Class<NotBeforeError>,
+    TokenExpiredError: Class<TokenExpiredError>,
+    ...
+  }
+}
diff --git a/definitions/npm/jsonwebtoken_v8.3.x/flow_v0.104.x-/jsonwebtoken_v8.3.x.js b/definitions/npm/jsonwebtoken_v8.3.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.3.x.js
similarity index 100%
rename from definitions/npm/jsonwebtoken_v8.3.x/flow_v0.104.x-/jsonwebtoken_v8.3.x.js
rename to definitions/npm/jsonwebtoken_v8.3.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.3.x.js
diff --git a/definitions/npm/jsonwebtoken_v8.3.x/flow_v0.201.x-/jsonwebtoken_v8.3.x.js b/definitions/npm/jsonwebtoken_v8.3.x/flow_v0.201.x-/jsonwebtoken_v8.3.x.js
new file mode 100644
index 0000000000..980b9a61c3
--- /dev/null
+++ b/definitions/npm/jsonwebtoken_v8.3.x/flow_v0.201.x-/jsonwebtoken_v8.3.x.js
@@ -0,0 +1,161 @@
+declare module "jsonwebtoken" {
+
+  declare class JsonWebTokenError extends Error {
+    name: string;
+    message: string;
+    inner: Error;
+  }
+
+  declare class TokenExpiredError extends Error {
+    name: string;
+    expiredAt: number;
+    inner: Error;
+  }
+
+  declare class NotBeforeError extends Error {
+    name: string;
+    date: Date;
+    inner: Error;
+  }
+
+  declare type Encodable = String | Buffer | Object;
+  declare type Key = {
+    key: string | Buffer,
+    passphrase: string | Buffer,
+    ...
+  };
+  declare type Algorithm =
+    'RS256'
+    | 'RS384'
+    | 'RS512'
+    | 'ES256'
+    | 'ES384'
+    | 'ES512'
+    | 'HS256'
+    | 'HS384'
+    | 'HS512'
+    | 'none';
+
+  declare type SignCallback = (err: Error, token: string) => void;
+  declare type SigningOptions<Headers> = $Shape<{
+    algorithm: Algorithm,
+    expiresIn: number | string,
+    notBefore: number | string,
+    audience: string | string[],
+    issuer: string | string[],
+    jwtid: string,
+    subject: string,
+    noTimestamp: boolean,
+    header: Headers,
+    keyid: string,
+    ...
+  }>;
+
+  declare type SigningOptionsWithAlgorithm<H> = SigningOptions<H> & { algorithm: Algorithm, ... };
+
+  declare type VerifyCallback = (err: JsonWebTokenError | NotBeforeError | TokenExpiredError | null, decoded: Payload) => void;
+  declare type VerifyOptionsWithAlgorithm = VerifyOptions & { algorithms: Array<Algorithm>, ... };
+  declare type VerifyOptions = $Shape<{
+    algorithms: Array<Algorithm>,
+    audience: string | string[],
+    issuer: string | string[],
+    ignoreExpiration: boolean,
+    ignoreNotBefore: boolean,
+    subject: string | string[],
+    clockTolerance: number,
+    maxAge: string | number,
+    clockTimestamp: number,
+    ...
+  }>;
+
+  declare type DecodingOptions = $Shape<{
+    complete: boolean,
+    json: boolean,
+    ...
+  }>;
+
+  declare interface Sign {
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer): string;
+
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>, callback: SignCallback): string;
+  }
+
+  declare type Payload = Object & {
+    jti?: string,
+    iss?: string,
+    sub?: string,
+    aud?: string | string[],
+    exp?: number,
+    iat?: number,
+    nbf?: number,
+    ...
+  }
+
+  declare type Token = {
+    header: {
+      typ: 'JWT',
+      alg: Algorithm,
+      ...
+    },
+    payload: Payload,
+    signature?: string,
+    ...
+  }
+
+  declare interface Decode {
+    (jwt: string): Payload;
+
+    (jwt: string, options: DecodingOptions): Payload;
+
+    (jwt: string, options: DecodingOptions & { complete: true, ... }): Token;
+  }
+
+  declare interface Verify {
+    (jwt: string, secretOrPrivateKey: string | Buffer): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions | VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions, callback: VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+  }
+
+  declare class TokenExpiredError extends Error {
+  }
+
+  declare class WebTokenError extends Error {
+  }
+
+  declare class NotBeforeError extends Error {
+  }
+
+  declare module.exports: {
+    sign: Sign,
+    decode: Decode,
+    verify: Verify,
+    JsonWebTokenError: Class<WebTokenError>,
+    NotBeforeError: Class<NotBeforeError>,
+    TokenExpiredError: Class<TokenExpiredError>,
+    ...
+  }
+}
diff --git a/definitions/npm/jsonwebtoken_v8.4.x/flow_v0.104.x-/jsonwebtoken_v8.4.x.js b/definitions/npm/jsonwebtoken_v8.4.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.4.x.js
similarity index 100%
rename from definitions/npm/jsonwebtoken_v8.4.x/flow_v0.104.x-/jsonwebtoken_v8.4.x.js
rename to definitions/npm/jsonwebtoken_v8.4.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.4.x.js
diff --git a/definitions/npm/jsonwebtoken_v8.4.x/flow_v0.201.x-/jsonwebtoken_v8.4.x.js b/definitions/npm/jsonwebtoken_v8.4.x/flow_v0.201.x-/jsonwebtoken_v8.4.x.js
new file mode 100644
index 0000000000..8122c31cbd
--- /dev/null
+++ b/definitions/npm/jsonwebtoken_v8.4.x/flow_v0.201.x-/jsonwebtoken_v8.4.x.js
@@ -0,0 +1,162 @@
+declare module "jsonwebtoken" {
+
+  declare class JsonWebTokenError extends Error {
+    name: string;
+    message: string;
+    inner: Error;
+  }
+
+  declare class TokenExpiredError extends Error {
+    name: string;
+    expiredAt: number;
+    inner: Error;
+  }
+
+  declare class NotBeforeError extends Error {
+    name: string;
+    date: Date;
+    inner: Error;
+  }
+
+  declare type Encodable = String | Buffer | Object;
+  declare type Key = {
+    key: string | Buffer,
+    passphrase: string | Buffer,
+    ...
+  };
+  declare type Algorithm =
+    'RS256'
+    | 'RS384'
+    | 'RS512'
+    | 'ES256'
+    | 'ES384'
+    | 'ES512'
+    | 'HS256'
+    | 'HS384'
+    | 'HS512'
+    | 'none';
+
+  declare type SignCallback = (err: Error, token: string) => void;
+  declare type SigningOptions<Headers> = $Shape<{
+    algorithm: Algorithm,
+    expiresIn: number | string,
+    notBefore: number | string,
+    audience: string | string[],
+    issuer: string | string[],
+    jwtid: string,
+    subject: string,
+    noTimestamp: boolean,
+    header: Headers,
+    keyid: string,
+    ...
+  }>;
+
+  declare type SigningOptionsWithAlgorithm<H> = SigningOptions<H> & { algorithm: Algorithm, ... };
+
+  declare type VerifyCallback = (err: JsonWebTokenError | NotBeforeError | TokenExpiredError | null, decoded: Payload) => void;
+  declare type VerifyOptionsWithAlgorithm = VerifyOptions & { algorithms: Array<Algorithm>, ... };
+  declare type VerifyOptions = $Shape<{
+    algorithms: Array<Algorithm>,
+    audience: string | string[],
+    issuer: string | string[],
+    ignoreExpiration: boolean,
+    ignoreNotBefore: boolean,
+    subject: string | string[],
+    clockTolerance: number,
+    maxAge: string | number,
+    clockTimestamp: number,
+    nonce?: string,
+    ...
+  }>;
+
+  declare type DecodingOptions = $Shape<{
+    complete: boolean,
+    json: boolean,
+    ...
+  }>;
+
+  declare interface Sign {
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer): string;
+
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>, callback: SignCallback): string;
+  }
+
+  declare type Payload = Object & {
+    jti?: string,
+    iss?: string,
+    sub?: string,
+    aud?: string | string[],
+    exp?: number,
+    iat?: number,
+    nbf?: number,
+    ...
+  }
+
+  declare type Token = {
+    header: {
+      typ: 'JWT',
+      alg: Algorithm,
+      ...
+    },
+    payload: Payload,
+    signature?: string,
+    ...
+  }
+
+  declare interface Decode {
+    (jwt: string): Payload;
+
+    (jwt: string, options: DecodingOptions): Payload;
+
+    (jwt: string, options: DecodingOptions & { complete: true, ... }): Token;
+  }
+
+  declare interface Verify {
+    (jwt: string, secretOrPrivateKey: string | Buffer): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions | VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions, callback: VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+  }
+
+  declare class TokenExpiredError extends Error {
+  }
+
+  declare class WebTokenError extends Error {
+  }
+
+  declare class NotBeforeError extends Error {
+  }
+
+  declare module.exports: {
+    sign: Sign,
+    decode: Decode,
+    verify: Verify,
+    JsonWebTokenError: Class<WebTokenError>,
+    NotBeforeError: Class<NotBeforeError>,
+    TokenExpiredError: Class<TokenExpiredError>,
+    ...
+  }
+}
diff --git a/definitions/npm/jsonwebtoken_v8.5.x/flow_v0.104.x-/jsonwebtoken_v8.5.x.js b/definitions/npm/jsonwebtoken_v8.5.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.5.x.js
similarity index 100%
rename from definitions/npm/jsonwebtoken_v8.5.x/flow_v0.104.x-/jsonwebtoken_v8.5.x.js
rename to definitions/npm/jsonwebtoken_v8.5.x/flow_v0.104.x-v0.200.x/jsonwebtoken_v8.5.x.js
diff --git a/definitions/npm/jsonwebtoken_v8.5.x/flow_v0.201.x-/jsonwebtoken_v8.5.x.js b/definitions/npm/jsonwebtoken_v8.5.x/flow_v0.201.x-/jsonwebtoken_v8.5.x.js
new file mode 100644
index 0000000000..37ef102146
--- /dev/null
+++ b/definitions/npm/jsonwebtoken_v8.5.x/flow_v0.201.x-/jsonwebtoken_v8.5.x.js
@@ -0,0 +1,164 @@
+declare module "jsonwebtoken" {
+
+  declare class JsonWebTokenError extends Error {
+    name: string;
+    message: string;
+    inner: Error;
+  }
+
+  declare class TokenExpiredError extends Error {
+    name: string;
+    expiredAt: number;
+    inner: Error;
+  }
+
+  declare class NotBeforeError extends Error {
+    name: string;
+    date: Date;
+    inner: Error;
+  }
+
+  declare type Encodable = String | Buffer | Object;
+  declare type Key = {
+    key: string | Buffer,
+    passphrase: string | Buffer,
+    ...
+  };
+  declare type Algorithm =
+    'RS256'
+    | 'RS384'
+    | 'RS512'
+    | 'ES256'
+    | 'ES384'
+    | 'ES512'
+    | 'HS256'
+    | 'HS384'
+    | 'HS512'
+    | 'none';
+
+  declare type SignCallback = (err: Error, token: string) => void;
+  declare type SigningOptions<Headers> = $Shape<{
+    algorithm: Algorithm,
+    expiresIn: number | string,
+    notBefore: number | string,
+    audience: string | string[],
+    issuer: string | string[],
+    jwtid: string,
+    subject: string,
+    noTimestamp: boolean,
+    header: Headers,
+    keyid: string,
+    ...
+  }>;
+
+  declare type SigningOptionsWithAlgorithm<H> = SigningOptions<H> & { algorithm: Algorithm, ... };
+
+  declare type VerifyCallback = (err: JsonWebTokenError | NotBeforeError | TokenExpiredError | null, decoded: Payload) => void;
+  declare type VerifyOptionsWithAlgorithm = VerifyOptions & { algorithms: Array<Algorithm>, ... };
+  declare type VerifyOptions = $Shape<{
+    algorithms: Array<Algorithm>,
+    audience: string | string[],
+    issuer: string | string[],
+    ignoreExpiration: boolean,
+    ignoreNotBefore: boolean,
+    subject: string | string[],
+    clockTolerance: number,
+    maxAge: string | number,
+    clockTimestamp: number,
+    nonce?: string,
+    /** return an object with the decoded `{ payload, header, signature }` instead of only the usual content of the payload. */
+    complete?: boolean,
+    ...
+  }>;
+
+  declare type DecodingOptions = $Shape<{
+    complete: boolean,
+    json: boolean,
+    ...
+  }>;
+
+  declare interface Sign {
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer): string;
+
+    <P: Encodable>
+    (payload: P, secretOrPrivateKey: string | Buffer, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: string | Buffer, options: $Shape<SigningOptions<H>>, callback: SignCallback): string;
+
+    <P: Encodable, H>
+    (payload: P, secretOrPrivateKey: Key, options: SigningOptionsWithAlgorithm<H>, callback: SignCallback): string;
+  }
+
+  declare type Payload = Object & {
+    jti?: string,
+    iss?: string,
+    sub?: string,
+    aud?: string | string[],
+    exp?: number,
+    iat?: number,
+    nbf?: number,
+    ...
+  }
+
+  declare type Token = {
+    header: {
+      typ: 'JWT',
+      alg: Algorithm,
+      ...
+    },
+    payload: Payload,
+    signature?: string,
+    ...
+  }
+
+  declare interface Decode {
+    (jwt: string): Payload;
+
+    (jwt: string, options: DecodingOptions): Payload;
+
+    (jwt: string, options: DecodingOptions & { complete: true, ... }): Token;
+  }
+
+  declare interface Verify {
+    (jwt: string, secretOrPrivateKey: string | Buffer): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions | VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: string | Buffer, options: VerifyOptions, callback: VerifyCallback): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm): Payload;
+
+    (jwt: string, secretOrPrivateKey: Key, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, callback: VerifyCallback): Payload;
+
+    (jwt: string, getKey: (header: { kid: ?string, ... }, callback: (err: ?Error, key?: string) => any) => any, options: VerifyOptionsWithAlgorithm, callback: VerifyCallback): Payload;
+  }
+
+  declare class TokenExpiredError extends Error {
+  }
+
+  declare class WebTokenError extends Error {
+  }
+
+  declare class NotBeforeError extends Error {
+  }
+
+  declare module.exports: {
+    sign: Sign,
+    decode: Decode,
+    verify: Verify,
+    JsonWebTokenError: Class<WebTokenError>,
+    NotBeforeError: Class<NotBeforeError>,
+    TokenExpiredError: Class<TokenExpiredError>,
+    ...
+  }
+}
diff --git a/definitions/npm/koa-json-body_v5.x.x/flow_v0.53.x-/koa-json-body_v5.x.x.js b/definitions/npm/koa-json-body_v5.x.x/flow_v0.201.x-/koa-json-body_v5.x.x.js
similarity index 100%
rename from definitions/npm/koa-json-body_v5.x.x/flow_v0.53.x-/koa-json-body_v5.x.x.js
rename to definitions/npm/koa-json-body_v5.x.x/flow_v0.201.x-/koa-json-body_v5.x.x.js
diff --git a/definitions/npm/koa-json-body_v5.x.x/flow_v0.53.x-v0.200.x/koa-json-body_v5.x.x.js b/definitions/npm/koa-json-body_v5.x.x/flow_v0.53.x-v0.200.x/koa-json-body_v5.x.x.js
new file mode 100644
index 0000000000..0e68bb8b3a
--- /dev/null
+++ b/definitions/npm/koa-json-body_v5.x.x/flow_v0.53.x-v0.200.x/koa-json-body_v5.x.x.js
@@ -0,0 +1,13 @@
+declare module 'koa-json-body' {
+  declare type Middleware = (
+    ctx: any,
+    next: () => Promise<void>
+  ) => Promise<void> | void;
+  declare type Options = $Shape<{|
+    fallback: boolean,
+    limit: string | number,
+    strict: boolean,
+  |}>;
+
+  declare module.exports: (options?: Options) => Middleware;
+}
diff --git a/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/mongodb_v3.5.x.js b/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/mongodb_v3.5.x.js
similarity index 100%
rename from definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/mongodb_v3.5.x.js
rename to definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/mongodb_v3.5.x.js
diff --git a/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/test_mongodb_v3.5.x_client.js b/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.5.x_client.js
similarity index 100%
rename from definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/test_mongodb_v3.5.x_client.js
rename to definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.5.x_client.js
diff --git a/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/test_mongodb_v3.5.x_docs_quick_start.js b/definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.5.x_docs_quick_start.js
similarity index 100%
rename from definitions/npm/mongodb_v3.5.x/flow_v0.114.x-/test_mongodb_v3.5.x_docs_quick_start.js
rename to definitions/npm/mongodb_v3.5.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.5.x_docs_quick_start.js
diff --git a/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/mongodb_v3.5.x.js b/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/mongodb_v3.5.x.js
new file mode 100644
index 0000000000..fe5bd55f54
--- /dev/null
+++ b/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/mongodb_v3.5.x.js
@@ -0,0 +1,420 @@
+// @flow
+
+declare module 'mongodb' {
+  import type { Readable } from 'stream';
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Admin.html
+  declare export type Admin = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/AggregationCursor.html
+  declare export type AggregationCursor = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/AutoEncrypter.html
+  declare export type AutoEncrypter = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Binary.html
+  declare export var Binary: any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BSONRegExp.html
+  declare export var BSONRegExp: any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkOperationBase.html
+  declare export type BulkOperationBase = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkWriteError.html
+  declare export var BulkWriteError: any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkWriteResult.html
+  declare export type BulkWriteResult = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ChangeStream.html
+  declare export type ChangeStream = any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ClientEncryption.html
+  declare export type ClientEncryption = any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ClientSession.html
+  declare export type ClientSession = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Code.html
+  declare export var Code: any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Collection.html
+  declare export type Collection = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/CommandCursor.html
+  declare export type CommandCursor = any; // TODO (use type shouldn't be instantiated)
+
+  declare export type CursorFlag = 'tailable' | 'oplogReplay' | 'noCursorTimeout' | 'awaitData' | 'partial';
+
+  declare export type CursorCloseOptions = {|
+    skipKillCursors?: boolean,
+  |};
+
+  declare export type CursorResultCallback<T> = (error: ?(typeof MongoError), result: T) => mixed;
+  declare export type CursorIteratorCallback<T> = (doc: T) => mixed;
+  declare export type CursorEndCallback = (error: ?(typeof MongoError)) => mixed;
+
+  // TODO
+  declare export type CollationOptions = any;
+
+  declare export type CursorCountOptions = {|
+    skip?: number,
+    limit?: number,
+    maxTimeMS?: number,
+    hint?: string,
+    readPreference?: ReadPreferenceValue,
+  |};
+
+  // TODO: type explain https://docs.mongodb.com/manual/reference/method/cursor.explain/#behavior
+  declare export type ExplainResult = { ... };
+
+  declare export type Projection<Doc: { ... }> = {
+    ...$ObjMap<Doc, () => (1 | -1 | boolean | string)>,
+    _id?: 1 | false,
+    ...,
+  };
+
+  // TODO
+  declare export type CursorOption = { ... };
+
+  declare export type StreamOptions<Input: { ... }, Doc: { ... }> = {|
+    transform: Input => Doc,
+  |};
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Cursor.html
+  declare export interface Cursor<Doc: { ... }> extends Readable {
+    addCursorFlag(flag: CursorFlag, value: boolean): Cursor<Doc>;
+    addQueryModifier(name: string, value: string | number | boolean): Cursor<Doc>;
+    batchSize(value: number): Cursor<Doc>;
+    clone(): Cursor<Doc>;
+    close(options: CursorCloseOptions, cb: CursorResultCallback<null>): void;
+    close(options: CursorCloseOptions): Promise<null>;
+    close(cb: CursorResultCallback<null>): void;
+    close(): Promise<null>;
+    collation(valie: CollationOptions): Cursor<Doc>;
+    comment(value: string): Cursor<Doc>;
+    count(applySkipLimit: boolean, options: CursorCountOptions, callback: CursorResultCallback<number>): void;
+    count(applySkipLimit: boolean, options: CursorCountOptions): Promise<number>;
+    count(applySkipLimit: boolean, callback: CursorResultCallback<number>): void;
+    count(applySkipLimit: boolean): Promise<number>;
+    count(callback: CursorResultCallback<number>): void;
+    count(): Promise<number>;
+    // deprecated
+    each(CursorResultCallback<Doc>): null;
+    explain(CursorResultCallback<ExplainResult>): void;
+    explain(): Promise<ExplainResult>;
+    filter(filter: $Shape<Doc>): Cursor<Doc>;
+    forEach(iterator: CursorIteratorCallback<Doc>, callback: CursorEndCallback): Cursor<Doc>;
+    forEach(iterator: CursorIteratorCallback<Doc>): Promise<null>;
+    hasNext(callback: CursorResultCallback<boolean>): void;
+    hasNext(): Promise<boolean>;
+    hint(hint: string): Cursor<Doc>;
+    isClosed(): boolean;
+    limit(value: number): Cursor<Doc>;
+    map<Input: { ... }>(transform: Input => Doc): Cursor<Doc>;
+    max(value: number): Cursor<Doc>;
+    maxAwaitTimeMS(value: number): Cursor<Doc>;
+    // Deprecated
+    maxScan(maxScan: { ... }): Cursor<Doc>;
+    maxTimeMS(value: number): Cursor<Doc>;
+    min(value: number): Cursor<Doc>;
+    next(callback: CursorResultCallback<Doc>): void;
+    next(): Promise<Doc>;
+    project(value: Projection<Doc>): Cursor<Doc>;
+    returnKey(returnKey: boolean): Cursor<Doc>;
+    setCursorOption(field: 'numberOfRetries' | 'tailableRetryInterval', value: CursorOption): Cursor<Doc>;
+    setReadPreference(readPreference: ReadPreferenceValue): Cursor<Doc>;
+    // TODO: type showRecordId
+    showRecordId(showRecordId: { ... }): Cursor<Doc>;
+    skip(value: number): Cursor<Doc>;
+    // Deprecated
+    snapshot(snapshot: { ... }): Cursor<Doc>;
+    sort(keyOrList: $Keys<Doc>, direction: 1 | -1): Cursor<Doc>;
+    sort(keyOrList: [$Keys<Doc>, 1 | -1][]): Cursor<Doc>;
+    sort(keyOrList: { [string]: 1 | -1, ... }): Cursor<Doc>;
+    stream<Input: { ... }>(options: StreamOptions<Input, Doc>): Cursor<Doc>;
+    toArray(callback: CursorResultCallback<Doc[]>): void;
+    toArray(): Promise<Doc[]>;
+    transformStream<Input: { ... }>(options: StreamOptions<Input, Doc>): Readable;
+  }
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Db.html
+  declare export var Db: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/DBRef.html
+  declare export var DBRef: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Decimal128.html
+  declare export var Decimal128: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Double.html
+  declare export var Double: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/FindOperators.html
+  declare export type FindOperators = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucket.html
+  declare export var GridFSBucket: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucketReadStream.html
+  declare export type GridFSBucketReadStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucketWriteStream.html
+  declare export type GridFSBucketWriteStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridStore.html
+  declare export var GridStore: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridStoreStream.html
+  declare export type GridStoreStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Int32.html
+  declare export var Int32: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Logger.html
+  declare export var Logger: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Long.html
+  declare export var Long: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MaxKey.html
+  declare export var MaxKey: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MinKey.html
+  declare export var MinKey: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html
+  declare export class MongoClient {
+    static connect(url: string, options: MongoClientOptions, callback: ConnectCallback): MongoClient;
+    static connect(url: string, callback: ConnectCallback): MongoClient;
+    static connect(url: string, options?: MongoClientOptions): Promise<MongoClient>;
+
+    constructor(url: string, options?: MongoClientOptions, callback?: ConnectCallback): MongoClient;
+    constructor(url: string, callback?: ConnectCallback): MongoClient;
+
+    close(force: boolean, callback: NoResultCallback): void;
+    close(callback: NoResultCallback): void;
+    close(force?: boolean): Promise<void>;
+
+    connect(callback: ConnectCallback): void;
+    connect(): Promise<MongoClient>;
+
+    db(dbName?: string, options?: DbOptions): typeof Db;
+
+    isConnected(options?: DbOptions): boolean;
+
+    startSession(options?: SessionOptions): ClientSession;
+
+    watch(pipeline?: AggregationPipeline, options?: ClientWatchOptions): ChangeStream;
+
+    withSession(options?: WithSessionOptions, operation: Operation): Promise<void>; // TODO confirm return
+    withSession(operation: Operation): Promise<void>; // TODO confirm return
+  }
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoCryptError.html
+  declare export var MongoCryptError: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoError.html
+  declare export var MongoError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoNetworkError.html
+  declare export var MongoNetworkError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoParseError.html
+  declare export var MongoParseError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Mongos.html
+  declare export var Mongos: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoServerSelectionError.html
+  declare export var MongoServerSelectionError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoTimeoutError.html
+  declare export var MongoTimeoutError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoWriteConcernError.html
+  declare export var MongoWriteConcernError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ObjectID.html
+  declare export var ObjectID: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/OrderedBulkOperation.html
+  declare export type OrderedBulkOperation = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ReplSet.html
+  declare export var ReplSet: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Server.html
+  declare export var Server: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Symbol.html
+  declare export var Symbol: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Timestamp.html
+  declare export type Timestamp = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/UnorderedBulkOperation.html
+  declare export type UnorderedBulkOperation = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/WriteConcernError.html
+  declare export var WriteConcernError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/WriteError.html
+  declare export type WriteError = any; // TODO (use type shouldn't be instantiated)
+
+  declare export type ReadPreference = {|
+    PRIMARY: 'primary',
+    PRIMARY_PREFERRED: 'primaryPreferred',
+    SECONDARY: 'secondary',
+    SECONDARY_PREFERRED: 'secondaryPreferred',
+    NEAREST: 'nearest',
+  |};
+  declare export type ReadPreferenceValue = 'primary' | 'primaryPreferred' | 'secondary'
+    | 'secondaryPreferred' | 'nearest'
+
+  declare export type ReadConcernLevel = 'local' | 'available' | 'majority' | 'linearizable' | 'snapshot';
+
+  declare export type ReadConcern = {|
+    type: ReadConcernLevel,
+  |}
+
+  declare export type DriverInfoOptionsObject = {|
+    name?: string,
+    version?: string,
+    platform?: string,
+  |};
+
+  declare export type KMSProviders = {|
+    aws: {|
+      accessKeyId?: string,
+      secretAccessKey?: string,
+    |},
+    local: {|
+      key?: Buffer,
+    |},
+  |};
+
+  declare export type AutoEncryptionOptionsObject = {|
+    keyVaultClient?: MongoClient,
+    keyVaultNamespace?: string,
+    kmsProviders?: KMSProviders,
+    schemaMap?: { [string]: mixed, ... },
+    bypassAutoEncryption?: boolean,
+    options?: {|
+      logger: LoggerInterface,
+    |},
+    extraOptions: {|
+      mongocryptdURI?: string,
+      mongocryptdBypassSpawn?: boolean,
+      mongocryptdSpawnPath?: string,
+      mongocryptdSpawnArgs?: string[]
+    |},
+  |};
+
+  declare export type ConnectCallback = (error: typeof MongoError, client: MongoClient) => mixed;
+  declare export type NoResultCallback = (error: typeof MongoError, null) => mixed;
+
+  declare export type PkFactory = {
+    createPk(): typeof ObjectID,
+    ...,
+  };
+
+  declare export type LoggerInterface = {|
+    debug(string): mixed,
+    info(string): mixed,
+    warn(string): mixed,
+    error(string): mixed,
+  |};
+
+  declare export type Auth = {|
+    user: string, password: string,
+  |}
+
+  declare export type MongoClientOptions = {|
+    poolSize?: number,
+    ssl?: boolean,
+    sslValidate?: boolean,
+    sslCA?: Buffer, // deprecated
+    sslCert?: Buffer, // deprecated
+    sslKey?: Buffer, // deprecated
+    sslPass?: string, // deprecated
+    sslCert?: Buffer, // deprecated
+    sslCRL?: Buffer, // deprecated
+    checkServerIdentity?: boolean | ((servername: string, cert: string) => boolean); // deprecated
+    tls?: boolean,
+    tlsInsecure?: boolean,
+    tlsCAFile?: string,
+    tlsCertificateKeyFile?: string,
+    tlsCertificateKeyFilePassword?: string,
+    tlsAllowInvalidCertificates?: boolean,
+    tlsAllowInvalidHostnames?: boolean,
+    autoReconnect?: boolean,
+    noDelay?: boolean,
+    keepAlive?: boolean,
+    keepAliveInitialDelay?: number,
+    connectTimeoutMS?: number,
+    socketTimeoutMS?: number,
+    family?: 4 | 6 | null,
+    reconnectTries?: number,
+    reconnectInterval?: number,
+    ha?: boolean,
+    haInterval?: number,
+    replicaSet?: string,
+    secondaryAcceptableLatencyMS?: number,
+    acceptableLatencyMS?: number,
+    connectWithNoPrimary?: boolean,
+    authSource?: string,
+    w?: string | number,
+    wtimeout?: number,
+    j?: boolean,
+    forceServerObjectId?: boolean,
+    serializeFunctions?: boolean,
+    ignoreUndefined?: boolean,
+    raw?: boolean,
+    bufferMaxEntries?: number,
+    readPreference?: ReadPreferenceValue,
+    pkFactory?: PkFactory,
+    promiseLibrary?: { ... }, // TODO
+    readConcern?: ReadConcern,
+    maxStalenessSeconds?: number,
+    loggerLevel?: 'error' | 'warn' | 'info' | 'debug',
+    logger?: LoggerInterface,
+    promoteValues?: boolean,
+    promoteBuffers?: boolean,
+    promoteLongs?: boolean,
+    domainsEnabled?: boolean,
+    validateOptions?: boolean,
+    appname?: string,
+    auth?: Auth,
+    authMechanism?: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1',
+    compression?: 'snappy' | 'zlib',
+    fsync?: boolean,
+    readPreferenceTags?: Array<{ [string]: string, ... }>,
+    numberOfRetries?: number,
+    auto_reconnect?: boolean,
+    monitorCommands?: boolean,
+    minSize?: number,
+    useNewUrlParser?: boolean,
+    useUnifiedTopology?: boolean,
+    autoEncryption?: AutoEncryptionOptionsObject,
+    driverInfo?: DriverInfoOptionsObject,
+  |};
+
+  declare export type DbOptions = {|
+    noListener?: boolean,
+    returnNonCachedInstance?: boolean,
+  |};
+
+  declare export type SessionOptions = { ... }; // TODO
+  declare export type Session = AnalyserNode; // TODO
+
+  declare export type AggregationStage = { ... }; // TODO
+  declare export type AggregationPipeline = $ReadOnlyArray<AggregationStage>;
+
+  declare export type ClientWatchOptions = { ... }; // TODO
+
+  declare export type WithSessionOptions = { ... }; // TODO
+
+  declare export type Operation = (session: Session) => mixed; // TODO
+}
\ No newline at end of file
diff --git a/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/test_mongodb_v3.5.x_client.js b/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/test_mongodb_v3.5.x_client.js
new file mode 100644
index 0000000000..0a340266c2
--- /dev/null
+++ b/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/test_mongodb_v3.5.x_client.js
@@ -0,0 +1,480 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import {
+  MongoClient,
+  type MongoClientOptions,
+  type ConnectCallback,
+  type PkFactory,
+  type ReadConcern,
+  type LoggerInterface,
+  type Auth,
+  type AutoEncryptionOptionsObject,
+  type DriverInfoOptionsObject,
+  type ReadPreferenceValue,
+  type Cursor,
+} from 'mongodb';
+import { Readable } from 'stream';
+
+describe('static connect', () => {
+  describe('Promises', () => {
+    it('url should be a string', () => {
+      const client: Promise<MongoClient> = MongoClient.connect(
+        'mongodb://localhost:27017'
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(2);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect();
+    });
+
+    it('should accepts options', (options: MongoClientOptions) => {
+      const client: Promise<MongoClient> = MongoClient.connect(
+        'mongodb://localhost:27017',
+        options
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        { invalidOptionsKey: 'string' }
+      );
+    });
+  });
+  describe('Callback', () => {
+    it('url should be a string', (cb: ConnectCallback) => {
+      const client: MongoClient = MongoClient.connect(
+        'mongodb://localhost:27017',
+        cb
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(2, cb);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(cb);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        (error: Error, c: string) => true
+      );
+    });
+
+    it('should accepts options', (cb: ConnectCallback, options: MongoClientOptions) => {
+      const client: MongoClient = MongoClient.connect(
+        'mongodb://localhost:27017',
+        options,
+        cb
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        { invalidOptionsKey: 'string' },
+        cb
+      );
+    });
+  });
+});
+
+describe('connect', () => {
+  describe('Promises', () => {
+    it('should return a promise', (client: MongoClient) => {
+      const c: Promise<MongoClient> = client.connect();
+      // $FlowExpectedError[incompatible-call]
+      client.connect('mongodb://localhost:27017');
+    });
+  });
+  describe('Callback', () => {
+    it('should accepts callback', (client: MongoClient, cb: ConnectCallback) => {
+      client.connect(cb);
+      // $FlowExpectedError[incompatible-call]
+      client.connect('mongodb://localhost:27017', cb);
+    });
+  });
+});
+
+describe('MongoClientOptions', (options: MongoClientOptions) => {
+  it('should supports poolSize options', () => {
+    const a: void | number = options.poolSize;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.poolSize;
+  });
+  it('should supports ssl options', () => {
+    const a: void | boolean = options.ssl;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ssl;
+  });
+  it('should supports sslValidate options', () => {
+    const a: void | boolean = options.sslValidate;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.sslValidate;
+  });
+  it('should supports sslCA options', () => {
+    const a: void | Buffer = options.sslCA;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCA;
+  });
+  it('should supports sslCert options', () => {
+    const a: void | Buffer = options.sslCert;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCert;
+  });
+  it('should supports sslKey options', () => {
+    const a: void | Buffer = options.sslKey;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslKey;
+  });
+  it('should supports sslPass options', () => {
+    const a: void | string = options.sslPass;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.sslPass;
+  });
+  it('should supports sslCRL options', () => {
+    const a: void | Buffer = options.sslCRL;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCRL;
+  });
+  it('should supports checkServerIdentity options', () => {
+    const a: MongoClientOptions = { checkServerIdentity: true };
+    const b: MongoClientOptions = {
+      checkServerIdentity: (servername: string, cert: string) => false,
+    };
+    // $FlowExpectedError[incompatible-type]
+    const c: MongoClientOptions = { checkServerIdentity: (a: boolean) => {} };
+  });
+  it('should supports tls options', () => {
+    const a: void | boolean = options.tls;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tls;
+  });
+  it('should supports tlsInsecure options', () => {
+    const a: void | boolean = options.tlsInsecure;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsInsecure;
+  });
+  it('should supports tlsCAFile options', () => {
+    const a: void | string = options.tlsCAFile;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCAFile;
+  });
+  it('should supports tlsCertificateKeyFile options', () => {
+    const a: void | string = options.tlsCertificateKeyFile;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCertificateKeyFile;
+  });
+  it('should supports tlsCertificateKeyFilePassword options', () => {
+    const a: void | string = options.tlsCertificateKeyFilePassword;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCertificateKeyFilePassword;
+  });
+  it('should supports tlsAllowInvalidCertificates options', () => {
+    const a: void | boolean = options.tlsAllowInvalidCertificates;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsAllowInvalidCertificates;
+  });
+  it('should supports tlsAllowInvalidHostnames options', () => {
+    const a: void | boolean = options.tlsAllowInvalidHostnames;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsAllowInvalidHostnames;
+  });
+  it('should supports autoReconnect options', () => {
+    const a: void | boolean = options.autoReconnect;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.autoReconnect;
+  });
+  it('should supports noDelay options', () => {
+    const a: void | boolean = options.noDelay;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.noDelay;
+  });
+  it('should supports keepAlive options', () => {
+    const a: void | boolean = options.keepAlive;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.keepAlive;
+  });
+  it('should supports keepAliveInitialDelay options', () => {
+    const a: void | number = options.keepAliveInitialDelay;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.keepAliveInitialDelay;
+  });
+  it('should supports connectTimeoutMS options', () => {
+    const a: void | number = options.connectTimeoutMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.connectTimeoutMS;
+  });
+  it('should supports socketTimeoutMS options', () => {
+    const a: void | number = options.socketTimeoutMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.socketTimeoutMS;
+  });
+  it('should supports keepAliveInitialDelay options', () => {
+    const a: 4 | 6 | void | null = options.family;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.family;
+  });
+  it('should supports reconnectTries options', () => {
+    const a: number | void = options.reconnectTries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.reconnectTries;
+  });
+  it('should supports reconnectInterval options', () => {
+    const a: number | void = options.reconnectInterval;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.family;
+  });
+  it('should supports ha options', () => {
+    const a: boolean | void = options.ha;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ha;
+  });
+  it('should supports haInterval options', () => {
+    const a: number | void = options.haInterval;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.haInterval;
+  });
+  it('should supports replicaSet options', () => {
+    const a: void | string = options.replicaSet;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.replicaSet;
+  });
+  it('should supports secondaryAcceptableLatencyMS options', () => {
+    const a: number | void = options.secondaryAcceptableLatencyMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.secondaryAcceptableLatencyMS;
+  });
+  it('should supports acceptableLatencyMS options', () => {
+    const a: number | void = options.acceptableLatencyMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.acceptableLatencyMS;
+  });
+  it('should supports connectWithNoPrimary options', () => {
+    const a: boolean | void = options.connectWithNoPrimary;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.connectWithNoPrimary;
+  });
+  it('should supports authSource options', () => {
+    const a: string | void = options.authSource;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.authSource;
+  });
+  it('should supports w options', () => {
+    const a: number | string | void = options.w;
+    // $FlowExpectedError[incompatible-type]
+    const b: number | string = options.w;
+  });
+  it('should supports wtimeout options', () => {
+    const a: number | void = options.wtimeout;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.wtimeout;
+  });
+  it('should supports j options', () => {
+    const a: boolean | void = options.j;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.j;
+  });
+  it('should supports forceServerObjectId options', () => {
+    const a: boolean | void = options.forceServerObjectId;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.forceServerObjectId;
+  });
+  it('should supports serializeFunctions options', () => {
+    const a: boolean | void = options.serializeFunctions;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.serializeFunctions;
+  });
+  it('should supports ignoreUndefined options', () => {
+    const a: boolean | void = options.ignoreUndefined;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ignoreUndefined;
+  });
+  it('should supports raw options', () => {
+    const a: boolean | void = options.raw;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.raw;
+  });
+  it('should supports bufferMaxEntries options', () => {
+    const a: number | void = options.bufferMaxEntries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.bufferMaxEntries;
+  });
+  it('should supports raw options', () => {
+    const a: boolean | void = options.raw;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.raw;
+  });
+  it('should supports readPreference options', () => {
+    const a: ReadPreferenceValue | void = options.readPreference;
+    // $FlowExpectedError[incompatible-type]
+    const b: ReadPreferenceValue = options.readPreference;
+  });
+  it('should supports pkFactory options', (pkFactory: PkFactory) => {
+    const a: PkFactory | void = options.pkFactory;
+    // $FlowExpectedError[incompatible-type]
+    const b: PkFactory = options.pkFactory;
+  });
+  it('should supports pkFactory options', (pkFactory: PkFactory) => {
+    const a: PkFactory | void = options.pkFactory;
+    // $FlowExpectedError[incompatible-type]
+    const b: PkFactory = options.pkFactory;
+  });
+  it('should supports promiseLibrary options', () => {
+    const a: { ... } | void = options.promiseLibrary;
+    // $FlowExpectedError[incompatible-type]
+    const b: { ... } = options.promiseLibrary;
+  });
+  it('should supports readConcern options', () => {
+    const a: ReadConcern | void = options.readConcern;
+    // $FlowExpectedError[incompatible-type]
+    const b: ReadConcern = options.readConcern;
+  });
+  it('should supports maxStalenessSeconds options', () => {
+    const a: number | void = options.maxStalenessSeconds;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.maxStalenessSeconds;
+  });
+  it('should supports loggerLevel options', () => {
+    const a: 'error' | 'warn' | 'info' | 'debug' | void = options.loggerLevel;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'error' | 'warn' | 'info' | 'debug' = options.loggerLevel;
+  });
+  it('should supports logger options', () => {
+    const a: LoggerInterface | void = options.logger;
+    // $FlowExpectedError[incompatible-type]
+    const b: LoggerInterface = options.logger;
+  });
+  it('should supports promoteValues options', () => {
+    const a: boolean | void = options.promoteValues;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteValues;
+  });
+  it('should supports promoteBuffers options', () => {
+    const a: boolean | void = options.promoteBuffers;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteBuffers;
+  });
+  it('should supports promoteLongs options', () => {
+    const a: boolean | void = options.promoteLongs;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteLongs;
+  });
+  it('should supports domainsEnabled options', () => {
+    const a: boolean | void = options.domainsEnabled;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.domainsEnabled;
+  });
+  it('should supports validateOptions options', () => {
+    const a: boolean | void = options.validateOptions;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.validateOptions;
+  });
+  it('should supports appname options', () => {
+    const a: string | void = options.appname;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.appname;
+  });
+  it('should supports auth options', () => {
+    const a: Auth | void = options.auth;
+    // $FlowExpectedError[incompatible-type]
+    const b: Auth = options.auth;
+  });
+  it('should supports authMechanism options', () => {
+    const a: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1' | void = options.authMechanism;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1' = options.authMechanism;
+  });
+  it('should supports compression options', () => {
+    const a: 'snappy' | 'zlib' | void = options.compression;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'snappy' | 'zlib' = options.compression;
+  });
+  it('should supports fsync options', () => {
+    const a: boolean | void = options.fsync;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.fsync;
+  });
+  it('should supports readPreferenceTags options', () => {
+    const a: Array<{ [string]: string, ... }> | void = options.readPreferenceTags;
+    // $FlowExpectedError[incompatible-type]
+    const b: Array<{ [string]: string, ... }> = options.readPreferenceTags;
+  });
+  it('should supports numberOfRetries options', () => {
+    const a: number | void = options.numberOfRetries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.numberOfRetries;
+  });
+  it('should supports auto_reconnect options', () => {
+    const a: boolean | void = options.auto_reconnect;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.auto_reconnect;
+  });
+  it('should supports monitorCommands options', () => {
+    const a: boolean | void = options.monitorCommands;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.monitorCommands;
+  });
+  it('should supports minSize options', () => {
+    const a: number | void = options.minSize;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.minSize;
+  });
+  it('should supports useNewUrlParser options', () => {
+    const a: boolean | void = options.useNewUrlParser;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.useNewUrlParser;
+  });
+  it('should supports useUnifiedTopology options', () => {
+    const a: boolean | void = options.useUnifiedTopology;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.useUnifiedTopology;
+  });
+  it('should supports autoEncryption options', () => {
+    const a: AutoEncryptionOptionsObject | void = options.autoEncryption;
+    // $FlowExpectedError[incompatible-type]
+    const b: AutoEncryptionOptionsObject = options.autoEncryption;
+  });
+  it('should supports driverInfo options', () => {
+    const a: DriverInfoOptionsObject | void = options.driverInfo;
+    // $FlowExpectedError[incompatible-type]
+    const b: DriverInfoOptionsObject = options.driverInfo;
+  });
+});
+
+describe('Cursor', () => {
+  it('should supports example from doc', (cursor: Cursor<{ a: number, ... }>) => {
+    cursor
+      .project({ a: 1 })
+      .skip(1)
+      .limit(10)
+      .batchSize(5)
+      .filter({ a: 1 })
+      .comment('add a comment')
+      .addCursorFlag('tailable', true)
+      .addCursorFlag('oplogReplay', true)
+      .addCursorFlag('noCursorTimeout', true)
+      .addCursorFlag('awaitData', true)
+      .addCursorFlag('partial', true)
+      .max(10)
+      .maxTimeMS(1000)
+      .min(100)
+      .returnKey(true)
+      .setReadPreference("primary")
+      .sort([['a', 1]])
+      .hint('a_1');
+  });
+  it('should extends readable', (cursor: Cursor<{ ... }>) => {
+    if (cursor instanceof Readable) {
+      // cursor is Readable
+
+      cursor.read(5);
+
+      // $FlowExpectedError[incompatible-call]
+      cursor.read("5");
+    } else {
+      // This should never happen
+      (cursor: empty)
+    }
+  });
+  it('should supports doc', (cursor: Cursor<{| a: number |}>) => {
+    cursor.filter({ a: 1 });
+
+    // $FlowExpectedError[prop-missing]
+    cursor.filter({ b: 3 });
+  });
+});
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/test_mongodb_v3.6.x_docs_quick_start.js b/definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/test_mongodb_v3.5.x_docs_quick_start.js
similarity index 100%
rename from definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/test_mongodb_v3.6.x_docs_quick_start.js
rename to definitions/npm/mongodb_v3.5.x/flow_v0.201.x-/test_mongodb_v3.5.x_docs_quick_start.js
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/mongodb_v3.6.x.js b/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/mongodb_v3.6.x.js
similarity index 100%
rename from definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/mongodb_v3.6.x.js
rename to definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/mongodb_v3.6.x.js
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/test_mongodb_v3.6.x_client.js b/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.6.x_client.js
similarity index 100%
rename from definitions/npm/mongodb_v3.6.x/flow_v0.114.x-/test_mongodb_v3.6.x_client.js
rename to definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.6.x_client.js
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.6.x_docs_quick_start.js b/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.6.x_docs_quick_start.js
new file mode 100644
index 0000000000..e58785379d
--- /dev/null
+++ b/definitions/npm/mongodb_v3.6.x/flow_v0.114.x-v0.200.x/test_mongodb_v3.6.x_docs_quick_start.js
@@ -0,0 +1,97 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import { Db } from 'mongodb';
+
+// http://mongodb.github.io/node-mongodb-native/3.5/quick-start/quick-start/
+describe('Quick Start', () => {
+  it('connect', () => {
+    const MongoClient = require('mongodb').MongoClient;
+    const assert = require('assert');
+
+    // Connection URL
+    const url = 'mongodb://localhost:27017';
+
+    // Database Name
+    const dbName = 'myproject';
+
+    // Create a new MongoClient
+    const client = new MongoClient(url);
+
+    // Use connect method to connect to the Server
+    client.connect(function(err) {
+      assert.equal(null, err);
+      console.log("Connected successfully to server");
+
+      const db = client.db(dbName);
+
+      client.close();
+    });
+  });
+
+  it('insertDocuments', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Insert some documents
+    collection.insertMany([
+      {a : 1}, {a : 2}, {a : 3}
+    ], function(err, result) {
+      assert.equal(err, null);
+      assert.equal(3, result.result.n);
+      assert.equal(3, result.ops.length);
+      console.log("Inserted 3 documents into the collection");
+      callback();
+    });
+  });
+
+  it('findDocuments', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Find some documents
+    collection.find({'a': 3}).toArray(function(err, docs) {
+      assert.equal(err, null);
+      console.log("Found the following records");
+      console.log(docs);
+      callback();
+    });
+  });
+
+  it('updateDocument', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Update document where a is 2, set b equal to 1
+    collection.updateOne({ a : 2 }, { $set: { b : 1 } }, function(err, result) {
+      assert.equal(err, null);
+      assert.equal(1, result.result.n);
+      console.log("Updated the document with the field a equal to 2");
+      callback();
+    });
+  });
+
+  it('removeDocument', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Delete document where a is 3
+    collection.deleteOne({ a : 3 }, function(err, result) {
+      assert.equal(err, null);
+      assert.equal(1, result.result.n);
+      console.log("Removed the document with the field a equal to 3");
+      callback();
+    });
+  });
+
+  it('indexCollection', (db: typeof Db, callback: () => void) => {
+    db.collection('documents').createIndex(
+      { "a": 1 },
+        null,
+        function(err, results) {
+          console.log(results);
+          callback();
+      }
+    );
+  });
+})
\ No newline at end of file
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/mongodb_v3.6.x.js b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/mongodb_v3.6.x.js
new file mode 100644
index 0000000000..016106e5e2
--- /dev/null
+++ b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/mongodb_v3.6.x.js
@@ -0,0 +1,667 @@
+// @flow
+
+declare module 'mongodb' {
+  import type { Readable } from 'stream';
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Admin.html
+  declare export type Admin = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/AggregationCursor.html
+  declare export type AggregationCursor = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/AutoEncrypter.html
+  declare export type AutoEncrypter = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Binary.html
+  declare export var Binary: any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BSONRegExp.html
+  declare export var BSONRegExp: any; // TODO
+
+  // TODO: type all possible operations
+  declare export type FilterQuery<Doc: { ... }> = $ReadOnly<$Shape<Doc> | { ... }>;
+
+  // TODO
+  declare export type UpdatePipeline = $ReadOnlyArray<{ ... }>;
+
+  declare export type BulkWriteInsertOneOperation<Doc: { ... }> = {|
+    +insertOne: {| 
+      +document: $ReadOnly<Doc>
+    |}
+  |};
+
+  declare export type BulkWriteUpdateOneOperation<Doc: { ... }> = {|
+    +updateOne: {| 
+      +filter?: FilterQuery<Doc>,
+      +update: UpdatePipeline | $Shape<Doc> | {|
+        +$set?: $Shape<Doc>,
+        +$setOnInsert?: $Shape<Doc>,
+      |},
+      +upsert?: boolean,
+      +collation?: CollationOptions,
+      +arrayFilters?: $ReadOnlyArray<FilterQuery<Doc>>,
+      +hint?: string | Hint,
+    |}
+  |};
+
+  declare export type BulkWriteUpdateManyOperation<Doc: { ... }> = {|
+    +updateMany: {|
+      +filter?: FilterQuery<Doc>,
+      +update: UpdatePipeline | $Shape<Doc> | {|
+        +$set?: $Shape<Doc>,
+        +$setOnInsert?: $Shape<Doc>,
+      |},
+      +upsert?: boolean,
+      +collation?: CollationOptions,
+      +arrayFilters?: $ReadOnlyArray<FilterQuery<Doc>>,
+      +hint?: string | Hint,
+    |}
+  |};
+
+  declare export type BulkWriteReplaceOneOperation<Doc: { ... }> = {|
+    +replaceOne: {| 
+      +filter?: FilterQuery<Doc>,
+      +replacement: Doc,
+      +upsert?: boolean,
+      +collation?: CollationOptions,
+      +hint?: string | Hint,
+    |}
+  |};
+
+  declare export type BulkWriteDeleteOneOperation<Doc: { ... }> = {|
+    +deleteOne: {| 
+      +filter?: FilterQuery<Doc>,
+      +collation?: CollationOptions,
+    |}
+  |};
+
+  declare export type BulkWriteDeleteManyOperation<Doc: { ... }> = {|
+    +deleteMany: {| 
+      +filter?: FilterQuery<Doc>,
+      +collation?: CollationOptions,
+    |}
+  |};
+
+  declare export type BulkWriteOperation<Doc: { ... }> = 
+    | BulkWriteInsertOneOperation<Doc>
+    | BulkWriteUpdateOneOperation<Doc> 
+    | BulkWriteUpdateManyOperation<Doc>
+    | BulkWriteReplaceOneOperation<Doc>
+    | BulkWriteDeleteOneOperation<Doc>
+    | BulkWriteDeleteManyOperation<Doc>;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkOperationBase.html
+  declare export type BulkOperationBase = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkWriteError.html
+  declare type IBulkWriteError = any;
+  declare export var BulkWriteError: IBulkWriteError; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/BulkWriteResult.html
+  declare export type BulkWriteResult = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ChangeStream.html
+  declare export type ChangeStream = any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ClientEncryption.html
+  declare export type ClientEncryption = any; // TODO
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ClientSession.html
+  declare export type ClientSession = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Code.html
+  declare export var Code: any; // TODO
+
+  declare export type BulkWriteOpResult = {| 
+    insertedCount: number,  
+    matchedCount: number,  
+    modifiedCount: number,  
+    deletedCount: number,  
+    upsertedCount: number,  
+    insertedIds: { [number]: IObjectID, ... },  
+    upsertedIds: { [number]: IObjectID, ... },  
+    result: { ... },  
+  |};
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Collection.html
+  declare export interface Collection<Doc: { ... } = { ... }> {
+    +collectionName: string;
+    +dbName: string;
+    +hint: Hint;
+    +namespace: string;
+    +readConcern: ReadConcern;
+    +readPreference: ReadPreference;
+    +writeConcern: WriteConcern;
+    aggregate(
+      pipeline: AggregationPipeline, 
+      options?: AggregateOptions,
+    ): AggregationCursor;
+    aggregate(
+      pipeline: AggregationPipeline, 
+      options: AggregateOptions,
+      (err: IMongoError, cursor: AggregationCursor) => mixed,
+    ): void;
+    aggregate(
+      pipeline: AggregationPipeline, 
+      (err: IMongoError, cursor: AggregationCursor) => mixed,
+    ): void;
+    bulkWrite(
+      operations: $ReadOnlyArray<BulkWriteOperation<Doc>>,
+      options?: BulkWriteOptions<Doc>,
+    ): Promise<BulkWriteOpResult>;
+    bulkWrite(
+      operations: BulkWriteOperation<Doc>,
+      options: BulkWriteOptions<Doc>,
+      (err: IBulkWriteError, result: BulkWriteOpResult) => mixed,
+    ): void;
+    bulkWrite(
+      operations: BulkWriteOperation<Doc>,
+      (err: IBulkWriteError, result: BulkWriteOpResult) => mixed,
+    ): void;
+    count(
+      query: FilterQuery<Doc>,
+      options?: CollectionCountOptions,
+    ): Promise<number>;
+    count(
+      query: FilterQuery<Doc>,
+      options: CollectionCountOptions,
+      (err: IMongoError, result: number) => mixed,
+    ): void;
+    count(
+      query: FilterQuery<Doc>,
+      (err: IMongoError, result: number) => mixed,
+    ): void;
+    countDocuments(
+      query: FilterQuery<Doc>,
+      options?: CollectionCountDocumentsOptions,
+    ): Promise<number>;
+    countDocuments(
+      query: FilterQuery<Doc>,
+      options: CollectionCountDocumentsOptions,
+      (err: IMongoError, result: number) => mixed,
+    ): void;
+    countDocuments(
+      query: FilterQuery<Doc>,
+      (err: IMongoError, result: number) => mixed,
+    ): void;
+    createIndex(...any[]): any;
+    createIndexes(...any[]): any;
+    deleteMany(...any[]): any;
+    deleteOne(...any[]): any;
+    distinct(...any[]): any;
+    drop(...any[]): any;
+    dropAllIndexes(...any[]): any;
+    dropIndex(...any[]): any;
+    dropIndexes(...any[]): any;
+    ensureIndex(...any[]): any;
+    estimatedDocumentCount(...any[]): any;
+    find(...any[]): any;
+    findAndModify(...any[]): any;
+    findAndRemove(...any[]): any;
+    findOne(...any[]): any;
+    findOneAndDelete(...any[]): any;
+    findOneAndReplace(...any[]): any;
+    findOneAndUpdate(...any[]): any;
+    geoHaystackSearch(...any[]): any;
+    group(...any[]): any;
+    indexes(...any[]): any;
+    indexExists(...any[]): any;
+    indexInformation(...any[]): any;
+    initializeOrderedBulkOp(...any[]): any;
+    initializeUnorderedBulkOp(...any[]): any;
+    insert(...any[]): any;
+    insertMany(...any[]): any;
+    insertOne(...any[]): any;
+    isCapped(...any[]): any;
+    listIndexes(...any[]): any;
+    mapReduce(...any[]): any;
+    options(...any[]): any;
+    parallelCollectionScan(...any[]): any;
+    reIndex(...any[]): any;
+    remove(...any[]): any;
+    rename(...any[]): any;
+    replaceOne(...any[]): any;
+    save(...any[]): any;
+    stats(...any[]): any;
+    update(...any[]): any;
+    updateMany(...any[]): any;
+    updateOne(...any[]): any;
+    watch(...any[]): any;
+  }
+
+  declare export type CollectionCountOptions = {|
+    skip?: number,
+    limit?: number,
+    maxTimeMS?: number,
+    hint?: string,
+    readPreference?: ReadPreferenceValue,
+    collation?: CollationOptions,
+    session?: ClientSession,
+  |};
+
+  declare export type CollectionCountDocumentsOptions = {|
+    skip?: number,
+    limit?: number,
+    maxTimeMS?: number,
+    hint?: string,
+    collation?: CollationOptions,
+  |};
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/CommandCursor.html
+  declare export type CommandCursor = any; // TODO (use type shouldn't be instantiated)
+
+  declare export type CursorFlag = 'tailable' | 'oplogReplay' | 'noCursorTimeout' | 'awaitData' | 'partial';
+
+  declare export type CursorCloseOptions = {|
+    skipKillCursors?: boolean,
+  |};
+
+  declare export type CursorResultCallback<T> = (error: ?(IMongoError), result: T) => mixed;
+  declare export type CursorIteratorCallback<T> = (doc: T) => mixed;
+  declare export type CursorEndCallback = (error: ?(IMongoError)) => mixed;
+
+  // TODO
+  declare export type CollationOptions = $ReadOnly<{ ... }>;
+
+  declare export type CursorCountOptions = {|
+    skip?: number,
+    limit?: number,
+    maxTimeMS?: number,
+    hint?: string,
+    readPreference?: ReadPreferenceValue,
+  |};
+
+  // TODO: type explain https://docs.mongodb.com/manual/reference/method/cursor.explain/#behavior
+  declare export type ExplainResult = { ... };
+
+  declare export type Projection<Doc: { ... }> = {
+    ...$ObjMap<Doc, () => (1 | -1 | boolean | string)>,
+    _id?: 1 | false,
+    ...,
+  };
+
+  // TODO
+  declare export type CursorOption = { ... };
+
+  declare export type StreamOptions<Input: { ... }, Doc: { ... }> = {|
+    transform: Input => Doc,
+  |};
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Cursor.html
+  declare export interface Cursor<Doc: { ... }> extends Readable {
+    addCursorFlag(flag: CursorFlag, value: boolean): Cursor<Doc>;
+    addQueryModifier(name: string, value: string | number | boolean): Cursor<Doc>;
+    batchSize(value: number): Cursor<Doc>;
+    clone(): Cursor<Doc>;
+    close(options: CursorCloseOptions, cb: CursorResultCallback<null>): void;
+    close(options: CursorCloseOptions): Promise<null>;
+    close(cb: CursorResultCallback<null>): void;
+    close(): Promise<null>;
+    collation(valie: CollationOptions): Cursor<Doc>;
+    comment(value: string): Cursor<Doc>;
+    count(applySkipLimit: boolean, options: CursorCountOptions, callback: CursorResultCallback<number>): void;
+    count(applySkipLimit: boolean, options: CursorCountOptions): Promise<number>;
+    count(applySkipLimit: boolean, callback: CursorResultCallback<number>): void;
+    count(applySkipLimit: boolean): Promise<number>;
+    count(callback: CursorResultCallback<number>): void;
+    count(): Promise<number>;
+    // deprecated
+    each(CursorResultCallback<Doc>): null;
+    explain(CursorResultCallback<ExplainResult>): void;
+    explain(): Promise<ExplainResult>;
+    filter(filter: $Shape<Doc>): Cursor<Doc>;
+    forEach(iterator: CursorIteratorCallback<Doc>, callback: CursorEndCallback): Cursor<Doc>;
+    forEach(iterator: CursorIteratorCallback<Doc>): Promise<null>;
+    hasNext(callback: CursorResultCallback<boolean>): void;
+    hasNext(): Promise<boolean>;
+    hint(hint: string): Cursor<Doc>;
+    isClosed(): boolean;
+    limit(value: number): Cursor<Doc>;
+    map<Input: { ... }>(transform: Input => Doc): Cursor<Doc>;
+    max(value: number): Cursor<Doc>;
+    maxAwaitTimeMS(value: number): Cursor<Doc>;
+    // Deprecated
+    maxScan(maxScan: { ... }): Cursor<Doc>;
+    maxTimeMS(value: number): Cursor<Doc>;
+    min(value: number): Cursor<Doc>;
+    next(callback: CursorResultCallback<Doc>): void;
+    next(): Promise<Doc>;
+    project(value: Projection<Doc>): Cursor<Doc>;
+    returnKey(returnKey: boolean): Cursor<Doc>;
+    setCursorOption(field: 'numberOfRetries' | 'tailableRetryInterval', value: CursorOption): Cursor<Doc>;
+    setReadPreference(readPreference: ReadPreferenceValue): Cursor<Doc>;
+    // TODO: type showRecordId
+    showRecordId(showRecordId: { ... }): Cursor<Doc>;
+    skip(value: number): Cursor<Doc>;
+    // Deprecated
+    snapshot(snapshot: { ... }): Cursor<Doc>;
+    sort(keyOrList: $Keys<Doc>, direction: 1 | -1): Cursor<Doc>;
+    sort(keyOrList: [$Keys<Doc>, 1 | -1][]): Cursor<Doc>;
+    sort(keyOrList: { [string]: 1 | -1, ... }): Cursor<Doc>;
+    stream<Input: { ... }>(options: StreamOptions<Input, Doc>): Cursor<Doc>;
+    toArray(callback: CursorResultCallback<Doc[]>): void;
+    toArray(): Promise<Doc[]>;
+    transformStream<Input: { ... }>(options: StreamOptions<Input, Doc>): Readable;
+  }
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Db.html
+  declare export var Db: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/DBRef.html
+  declare export var DBRef: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Decimal128.html
+  declare export var Decimal128: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Double.html
+  declare export var Double: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/FindOperators.html
+  declare export type FindOperators = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucket.html
+  declare export var GridFSBucket: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucketReadStream.html
+  declare export type GridFSBucketReadStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridFSBucketWriteStream.html
+  declare export type GridFSBucketWriteStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridStore.html
+  declare export var GridStore: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/GridStoreStream.html
+  declare export type GridStoreStream = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Int32.html
+  declare export var Int32: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Logger.html
+  declare export var Logger: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Long.html
+  declare export var Long: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MaxKey.html
+  declare export var MaxKey: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MinKey.html
+  declare export var MinKey: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html
+  declare export class MongoClient {
+    static connect(url: string, options: MongoClientOptions, callback: ConnectCallback): MongoClient;
+    static connect(url: string, callback: ConnectCallback): MongoClient;
+    static connect(url: string, options?: MongoClientOptions): Promise<MongoClient>;
+
+    constructor(url: string, options?: MongoClientOptions, callback?: ConnectCallback): MongoClient;
+    constructor(url: string, callback?: ConnectCallback): MongoClient;
+
+    close(force: boolean, callback: NoResultCallback): void;
+    close(callback: NoResultCallback): void;
+    close(force?: boolean): Promise<void>;
+
+    connect(callback: ConnectCallback): void;
+    connect(): Promise<MongoClient>;
+
+    db(dbName?: string, options?: DbOptions): typeof Db;
+
+    isConnected(options?: DbOptions): boolean;
+
+    startSession(options?: SessionOptions): ClientSession;
+
+    watch(pipeline?: AggregationPipeline, options?: ClientWatchOptions): ChangeStream;
+
+    withSession(options?: WithSessionOptions, operation: Operation): Promise<void>; // TODO confirm return
+    withSession(operation: Operation): Promise<void>; // TODO confirm return
+  }
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoCryptError.html
+  declare export var MongoCryptError: any; // TODO;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/IMongoError.html
+  declare type IMongoError = any;
+  declare export var MongoError: IMongoError;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoNetworkError.html
+  declare export var MongoNetworkError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoParseError.html
+  declare export var MongoParseError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Mongos.html
+  declare export var Mongos: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoServerSelectionError.html
+  declare export var MongoServerSelectionError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoTimeoutError.html
+  declare export var MongoTimeoutError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/MongoWriteConcernError.html
+  declare export var MongoWriteConcernError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ObjectID.html
+  declare type IObjectID = any;
+  declare export var ObjectID: IObjectID;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/OrderedBulkOperation.html
+  declare export type OrderedBulkOperation = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/ReplSet.html
+  declare export var ReplSet: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Server.html
+  declare export var Server: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Symbol.html
+  declare export var Symbol: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/Timestamp.html
+  declare export type Timestamp = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/UnorderedBulkOperation.html
+  declare export type UnorderedBulkOperation = any; // TODO (use type shouldn't be instantiated)
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/WriteConcernError.html
+  declare export var WriteConcernError: any;
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/WriteError.html
+  declare export type WriteError = any; // TODO (use type shouldn't be instantiated)
+
+  declare export type ReadPreference = {|
+    PRIMARY: 'primary',
+    PRIMARY_PREFERRED: 'primaryPreferred',
+    SECONDARY: 'secondary',
+    SECONDARY_PREFERRED: 'secondaryPreferred',
+    NEAREST: 'nearest',
+  |};
+  declare export type ReadPreferenceValue = 'primary' | 'primaryPreferred' | 'secondary'
+    | 'secondaryPreferred' | 'nearest'
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/global.html#ReadConcern
+  declare export type ReadConcernLevel = 'local' | 'available' | 'majority' | 'linearizable' | 'snapshot';
+
+  // http://mongodb.github.io/node-mongodb-native/3.5/api/global.html#ReadConcern
+  declare export type ReadConcern = {|
+    level: ReadConcernLevel,
+  |}
+
+  declare export type DriverInfoOptionsObject = {|
+    name?: string,
+    version?: string,
+    platform?: string,
+  |};
+
+  declare export type KMSProviders = {|
+    aws: {|
+      accessKeyId?: string,
+      secretAccessKey?: string,
+    |},
+    local: {|
+      key?: Buffer,
+    |},
+  |};
+
+  declare export type AutoEncryptionOptionsObject = {|
+    keyVaultClient?: MongoClient,
+    keyVaultNamespace?: string,
+    kmsProviders?: KMSProviders,
+    schemaMap?: { [string]: mixed, ... },
+    bypassAutoEncryption?: boolean,
+    options?: {|
+      logger: LoggerInterface,
+    |},
+    extraOptions: {|
+      mongocryptdURI?: string,
+      mongocryptdBypassSpawn?: boolean,
+      mongocryptdSpawnPath?: string,
+      mongocryptdSpawnArgs?: string[]
+    |},
+  |};
+
+  declare export type ConnectCallback = (error: IMongoError, client: MongoClient) => mixed;
+  declare export type NoResultCallback = (error: IMongoError, null) => mixed;
+
+  declare export type PkFactory = {
+    createPk(): IObjectID,
+    ...,
+  };
+
+  declare export type LoggerInterface = {|
+    debug(string): mixed,
+    info(string): mixed,
+    warn(string): mixed,
+    error(string): mixed,
+  |};
+
+  declare export type Auth = {|
+    user: string, password: string,
+  |}
+
+  declare export type MongoClientOptions = {|
+    poolSize?: number,
+    ssl?: boolean,
+    sslValidate?: boolean,
+    sslCA?: Buffer, // deprecated
+    sslCert?: Buffer, // deprecated
+    sslKey?: Buffer, // deprecated
+    sslPass?: string, // deprecated
+    sslCert?: Buffer, // deprecated
+    sslCRL?: Buffer, // deprecated
+    checkServerIdentity?: boolean | ((servername: string, cert: string) => boolean); // deprecated
+    tls?: boolean,
+    tlsInsecure?: boolean,
+    tlsCAFile?: string,
+    tlsCertificateKeyFile?: string,
+    tlsCertificateKeyFilePassword?: string,
+    tlsAllowInvalidCertificates?: boolean,
+    tlsAllowInvalidHostnames?: boolean,
+    autoReconnect?: boolean,
+    noDelay?: boolean,
+    keepAlive?: boolean,
+    keepAliveInitialDelay?: number,
+    connectTimeoutMS?: number,
+    socketTimeoutMS?: number,
+    family?: 4 | 6 | null,
+    reconnectTries?: number,
+    reconnectInterval?: number,
+    ha?: boolean,
+    haInterval?: number,
+    replicaSet?: string,
+    secondaryAcceptableLatencyMS?: number,
+    acceptableLatencyMS?: number,
+    connectWithNoPrimary?: boolean,
+    authSource?: string,
+    w?: string | number,
+    wtimeout?: number,
+    j?: boolean,
+    forceServerObjectId?: boolean,
+    serializeFunctions?: boolean,
+    ignoreUndefined?: boolean,
+    raw?: boolean,
+    bufferMaxEntries?: number,
+    readPreference?: ReadPreferenceValue,
+    pkFactory?: PkFactory,
+    promiseLibrary?: { ... }, // TODO
+    readConcern?: ReadConcern,
+    maxStalenessSeconds?: number,
+    loggerLevel?: 'error' | 'warn' | 'info' | 'debug',
+    logger?: LoggerInterface,
+    promoteValues?: boolean,
+    promoteBuffers?: boolean,
+    promoteLongs?: boolean,
+    domainsEnabled?: boolean,
+    validateOptions?: boolean,
+    appname?: string,
+    auth?: Auth,
+    authMechanism?: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1',
+    compression?: 'snappy' | 'zlib',
+    fsync?: boolean,
+    readPreferenceTags?: $ReadOnlyArray<{ [string]: string, ... }>,
+    numberOfRetries?: number,
+    auto_reconnect?: boolean,
+    monitorCommands?: boolean,
+    minSize?: number,
+    useNewUrlParser?: boolean,
+    useUnifiedTopology?: boolean,
+    autoEncryption?: AutoEncryptionOptionsObject,
+    driverInfo?: DriverInfoOptionsObject,
+  |};
+
+  declare export type DbOptions = {|
+    noListener?: boolean,
+    returnNonCachedInstance?: boolean,
+  |};
+
+  declare export type SessionOptions = { ... }; // TODO
+  declare export type Session = AnalyserNode; // TODO
+
+  declare export type AggregationStage = { ... }; // TODO
+  declare export type AggregationPipeline = $ReadOnlyArray<AggregationStage>;
+
+  declare export type ClientWatchOptions = { ... }; // TODO
+
+  declare export type AggregateOptions = { 
+    +readPreference?: ReadPreferenceValue,
+    +batchSize?: number,
+    +cursor?: { batchSize?: number, ... },
+    +explain?: boolean,
+    +allowDiskUse?: boolean,
+    +maxTimeMS?: number,
+    +maxAwaitTimeMS?: number,
+    +bypassDocumentValidation?: boolean,
+    +raw?: boolean,
+    +promoteLongs?: boolean,
+    +promoteValues?: boolean,
+    +promoteBuffers?: boolean,
+    +collation?: CollationOptions,
+    +comment?: string,
+    +hint?: string | Hint,
+    +session?: ClientSession,
+    ...
+  };
+
+  declare export type Hint = $ReadOnly<{ ... }>;
+
+  declare export type WithSessionOptions = { ... }; // TODO
+
+  declare export type BulkWriteOptions<Doc> = {
+    +ordered?: boolean,
+    +bypassDocumentValidation?: boolean,
+    +arrayFilters?: $ReadOnlyArray<FilterQuery<Doc>>,
+    +w?: WriteConcern,
+    +wtimeout?: number,
+    +j?: boolean,
+    +checkKeys?: boolean,
+    +serializeFunctions?: boolean,
+    +ignoreUndefined?: boolean,
+    +session?: ClientSession,
+    ...,
+  }
+
+  declare export type WriteConcern = number | 'majority';
+
+  declare export type Operation = (session: Session) => mixed; // TODO
+}
\ No newline at end of file
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_client.js b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_client.js
new file mode 100644
index 0000000000..cd6e2936d7
--- /dev/null
+++ b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_client.js
@@ -0,0 +1,480 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import {
+  MongoClient,
+  type MongoClientOptions,
+  type ConnectCallback,
+  type PkFactory,
+  type ReadConcern,
+  type LoggerInterface,
+  type Auth,
+  type AutoEncryptionOptionsObject,
+  type DriverInfoOptionsObject,
+  type ReadPreferenceValue,
+  type Cursor,
+} from 'mongodb';
+import { Readable } from 'stream';
+
+describe('static connect', () => {
+  describe('Promises', () => {
+    it('url should be a string', () => {
+      const client: Promise<MongoClient> = MongoClient.connect(
+        'mongodb://localhost:27017'
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(2);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect();
+    });
+
+    it('should accepts options', (options: MongoClientOptions) => {
+      const client: Promise<MongoClient> = MongoClient.connect(
+        'mongodb://localhost:27017',
+        options
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        { invalidOptionsKey: 'string' }
+      );
+    });
+  });
+  describe('Callback', () => {
+    it('url should be a string', (cb: ConnectCallback) => {
+      const client: MongoClient = MongoClient.connect(
+        'mongodb://localhost:27017',
+        cb
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(2, cb);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(cb);
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        (error: Error, c: string) => true
+      );
+    });
+
+    it('should accepts options', (cb: ConnectCallback, options: MongoClientOptions) => {
+      const client: MongoClient = MongoClient.connect(
+        'mongodb://localhost:27017',
+        options,
+        cb
+      );
+      // $FlowExpectedError[incompatible-call]
+      MongoClient.connect(
+        'mongodb://localhost:27017',
+        { invalidOptionsKey: 'string' },
+        cb
+      );
+    });
+  });
+});
+
+describe('connect', () => {
+  describe('Promises', () => {
+    it('should return a promise', (client: MongoClient) => {
+      const c: Promise<MongoClient> = client.connect();
+      // $FlowExpectedError[incompatible-call]
+      client.connect('mongodb://localhost:27017');
+    });
+  });
+  describe('Callback', () => {
+    it('should accepts callback', (client: MongoClient, cb: ConnectCallback) => {
+      client.connect(cb);
+      // $FlowExpectedError[incompatible-call]
+      client.connect('mongodb://localhost:27017', cb);
+    });
+  });
+});
+
+describe('MongoClientOptions', (options: MongoClientOptions) => {
+  it('should supports poolSize options', () => {
+    const a: void | number = options.poolSize;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.poolSize;
+  });
+  it('should supports ssl options', () => {
+    const a: void | boolean = options.ssl;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ssl;
+  });
+  it('should supports sslValidate options', () => {
+    const a: void | boolean = options.sslValidate;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.sslValidate;
+  });
+  it('should supports sslCA options', () => {
+    const a: void | Buffer = options.sslCA;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCA;
+  });
+  it('should supports sslCert options', () => {
+    const a: void | Buffer = options.sslCert;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCert;
+  });
+  it('should supports sslKey options', () => {
+    const a: void | Buffer = options.sslKey;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslKey;
+  });
+  it('should supports sslPass options', () => {
+    const a: void | string = options.sslPass;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.sslPass;
+  });
+  it('should supports sslCRL options', () => {
+    const a: void | Buffer = options.sslCRL;
+    // $FlowExpectedError[incompatible-type]
+    const b: Buffer = options.sslCRL;
+  });
+  it('should supports checkServerIdentity options', () => {
+    const a: MongoClientOptions = { checkServerIdentity: true };
+    const b: MongoClientOptions = {
+      checkServerIdentity: (servername: string, cert: string) => false,
+    };
+    // $FlowExpectedError[incompatible-type]
+    const c: MongoClientOptions = { checkServerIdentity: (a: boolean) => {} };
+  });
+  it('should supports tls options', () => {
+    const a: void | boolean = options.tls;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tls;
+  });
+  it('should supports tlsInsecure options', () => {
+    const a: void | boolean = options.tlsInsecure;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsInsecure;
+  });
+  it('should supports tlsCAFile options', () => {
+    const a: void | string = options.tlsCAFile;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCAFile;
+  });
+  it('should supports tlsCertificateKeyFile options', () => {
+    const a: void | string = options.tlsCertificateKeyFile;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCertificateKeyFile;
+  });
+  it('should supports tlsCertificateKeyFilePassword options', () => {
+    const a: void | string = options.tlsCertificateKeyFilePassword;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.tlsCertificateKeyFilePassword;
+  });
+  it('should supports tlsAllowInvalidCertificates options', () => {
+    const a: void | boolean = options.tlsAllowInvalidCertificates;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsAllowInvalidCertificates;
+  });
+  it('should supports tlsAllowInvalidHostnames options', () => {
+    const a: void | boolean = options.tlsAllowInvalidHostnames;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.tlsAllowInvalidHostnames;
+  });
+  it('should supports autoReconnect options', () => {
+    const a: void | boolean = options.autoReconnect;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.autoReconnect;
+  });
+  it('should supports noDelay options', () => {
+    const a: void | boolean = options.noDelay;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.noDelay;
+  });
+  it('should supports keepAlive options', () => {
+    const a: void | boolean = options.keepAlive;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.keepAlive;
+  });
+  it('should supports keepAliveInitialDelay options', () => {
+    const a: void | number = options.keepAliveInitialDelay;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.keepAliveInitialDelay;
+  });
+  it('should supports connectTimeoutMS options', () => {
+    const a: void | number = options.connectTimeoutMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.connectTimeoutMS;
+  });
+  it('should supports socketTimeoutMS options', () => {
+    const a: void | number = options.socketTimeoutMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.socketTimeoutMS;
+  });
+  it('should supports keepAliveInitialDelay options', () => {
+    const a: 4 | 6 | void | null = options.family;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.family;
+  });
+  it('should supports reconnectTries options', () => {
+    const a: number | void = options.reconnectTries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.reconnectTries;
+  });
+  it('should supports reconnectInterval options', () => {
+    const a: number | void = options.reconnectInterval;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.family;
+  });
+  it('should supports ha options', () => {
+    const a: boolean | void = options.ha;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ha;
+  });
+  it('should supports haInterval options', () => {
+    const a: number | void = options.haInterval;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.haInterval;
+  });
+  it('should supports replicaSet options', () => {
+    const a: void | string = options.replicaSet;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.replicaSet;
+  });
+  it('should supports secondaryAcceptableLatencyMS options', () => {
+    const a: number | void = options.secondaryAcceptableLatencyMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.secondaryAcceptableLatencyMS;
+  });
+  it('should supports acceptableLatencyMS options', () => {
+    const a: number | void = options.acceptableLatencyMS;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.acceptableLatencyMS;
+  });
+  it('should supports connectWithNoPrimary options', () => {
+    const a: boolean | void = options.connectWithNoPrimary;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.connectWithNoPrimary;
+  });
+  it('should supports authSource options', () => {
+    const a: string | void = options.authSource;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.authSource;
+  });
+  it('should supports w options', () => {
+    const a: number | string | void = options.w;
+    // $FlowExpectedError[incompatible-type]
+    const b: number | string = options.w;
+  });
+  it('should supports wtimeout options', () => {
+    const a: number | void = options.wtimeout;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.wtimeout;
+  });
+  it('should supports j options', () => {
+    const a: boolean | void = options.j;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.j;
+  });
+  it('should supports forceServerObjectId options', () => {
+    const a: boolean | void = options.forceServerObjectId;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.forceServerObjectId;
+  });
+  it('should supports serializeFunctions options', () => {
+    const a: boolean | void = options.serializeFunctions;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.serializeFunctions;
+  });
+  it('should supports ignoreUndefined options', () => {
+    const a: boolean | void = options.ignoreUndefined;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.ignoreUndefined;
+  });
+  it('should supports raw options', () => {
+    const a: boolean | void = options.raw;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.raw;
+  });
+  it('should supports bufferMaxEntries options', () => {
+    const a: number | void = options.bufferMaxEntries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.bufferMaxEntries;
+  });
+  it('should supports raw options', () => {
+    const a: boolean | void = options.raw;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.raw;
+  });
+  it('should supports readPreference options', () => {
+    const a: ReadPreferenceValue | void = options.readPreference;
+    // $FlowExpectedError[incompatible-type]
+    const b: ReadPreferenceValue = options.readPreference;
+  });
+  it('should supports pkFactory options', (pkFactory: PkFactory) => {
+    const a: PkFactory | void = options.pkFactory;
+    // $FlowExpectedError[incompatible-type]
+    const b: PkFactory = options.pkFactory;
+  });
+  it('should supports pkFactory options', (pkFactory: PkFactory) => {
+    const a: PkFactory | void = options.pkFactory;
+    // $FlowExpectedError[incompatible-type]
+    const b: PkFactory = options.pkFactory;
+  });
+  it('should supports promiseLibrary options', () => {
+    const a: { ... } | void = options.promiseLibrary;
+    // $FlowExpectedError[incompatible-type]
+    const b: { ... } = options.promiseLibrary;
+  });
+  it('should supports readConcern options', () => {
+    const a: ReadConcern | void = options.readConcern;
+    // $FlowExpectedError[incompatible-type]
+    const b: ReadConcern = options.readConcern;
+  });
+  it('should supports maxStalenessSeconds options', () => {
+    const a: number | void = options.maxStalenessSeconds;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.maxStalenessSeconds;
+  });
+  it('should supports loggerLevel options', () => {
+    const a: 'error' | 'warn' | 'info' | 'debug' | void = options.loggerLevel;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'error' | 'warn' | 'info' | 'debug' = options.loggerLevel;
+  });
+  it('should supports logger options', () => {
+    const a: LoggerInterface | void = options.logger;
+    // $FlowExpectedError[incompatible-type]
+    const b: LoggerInterface = options.logger;
+  });
+  it('should supports promoteValues options', () => {
+    const a: boolean | void = options.promoteValues;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteValues;
+  });
+  it('should supports promoteBuffers options', () => {
+    const a: boolean | void = options.promoteBuffers;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteBuffers;
+  });
+  it('should supports promoteLongs options', () => {
+    const a: boolean | void = options.promoteLongs;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.promoteLongs;
+  });
+  it('should supports domainsEnabled options', () => {
+    const a: boolean | void = options.domainsEnabled;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.domainsEnabled;
+  });
+  it('should supports validateOptions options', () => {
+    const a: boolean | void = options.validateOptions;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.validateOptions;
+  });
+  it('should supports appname options', () => {
+    const a: string | void = options.appname;
+    // $FlowExpectedError[incompatible-type]
+    const b: string = options.appname;
+  });
+  it('should supports auth options', () => {
+    const a: Auth | void = options.auth;
+    // $FlowExpectedError[incompatible-type]
+    const b: Auth = options.auth;
+  });
+  it('should supports authMechanism options', () => {
+    const a: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1' | void = options.authMechanism;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'MDEFAULT' | 'GSSAPI' | 'PLAIN' | 'MONGODB-X509' | 'SCRAM-SHA-1' = options.authMechanism;
+  });
+  it('should supports compression options', () => {
+    const a: 'snappy' | 'zlib' | void = options.compression;
+    // $FlowExpectedError[incompatible-type]
+    const b: 'snappy' | 'zlib' = options.compression;
+  });
+  it('should supports fsync options', () => {
+    const a: boolean | void = options.fsync;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.fsync;
+  });
+  it('should supports readPreferenceTags options', () => {
+    const a: $ReadOnlyArray<{ [string]: string, ... }> | void = options.readPreferenceTags;
+    // $FlowExpectedError[incompatible-type]
+    const b: $ReadOnlyArray<{ [string]: string, ... }> = options.readPreferenceTags;
+  });
+  it('should supports numberOfRetries options', () => {
+    const a: number | void = options.numberOfRetries;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.numberOfRetries;
+  });
+  it('should supports auto_reconnect options', () => {
+    const a: boolean | void = options.auto_reconnect;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.auto_reconnect;
+  });
+  it('should supports monitorCommands options', () => {
+    const a: boolean | void = options.monitorCommands;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.monitorCommands;
+  });
+  it('should supports minSize options', () => {
+    const a: number | void = options.minSize;
+    // $FlowExpectedError[incompatible-type]
+    const b: number = options.minSize;
+  });
+  it('should supports useNewUrlParser options', () => {
+    const a: boolean | void = options.useNewUrlParser;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.useNewUrlParser;
+  });
+  it('should supports useUnifiedTopology options', () => {
+    const a: boolean | void = options.useUnifiedTopology;
+    // $FlowExpectedError[incompatible-type]
+    const b: boolean = options.useUnifiedTopology;
+  });
+  it('should supports autoEncryption options', () => {
+    const a: AutoEncryptionOptionsObject | void = options.autoEncryption;
+    // $FlowExpectedError[incompatible-type]
+    const b: AutoEncryptionOptionsObject = options.autoEncryption;
+  });
+  it('should supports driverInfo options', () => {
+    const a: DriverInfoOptionsObject | void = options.driverInfo;
+    // $FlowExpectedError[incompatible-type]
+    const b: DriverInfoOptionsObject = options.driverInfo;
+  });
+});
+
+describe('Cursor', () => {
+  it('should supports example from doc', (cursor: Cursor<{ a: number, ... }>) => {
+    cursor
+      .project({ a: 1 })
+      .skip(1)
+      .limit(10)
+      .batchSize(5)
+      .filter({ a: 1 })
+      .comment('add a comment')
+      .addCursorFlag('tailable', true)
+      .addCursorFlag('oplogReplay', true)
+      .addCursorFlag('noCursorTimeout', true)
+      .addCursorFlag('awaitData', true)
+      .addCursorFlag('partial', true)
+      .max(10)
+      .maxTimeMS(1000)
+      .min(100)
+      .returnKey(true)
+      .setReadPreference("primary")
+      .sort([['a', 1]])
+      .hint('a_1');
+  });
+  it('should extends readable', (cursor: Cursor<{ ... }>) => {
+    if (cursor instanceof Readable) {
+      // cursor is Readable
+
+      cursor.read(5);
+
+      // $FlowExpectedError[incompatible-call]
+      cursor.read("5");
+    } else {
+      // This should never happen
+      (cursor: empty)
+    }
+  });
+  it('should supports doc', (cursor: Cursor<{| a: number |}>) => {
+    cursor.filter({ a: 1 });
+
+    // $FlowExpectedError[prop-missing]
+    cursor.filter({ b: 3 });
+  });
+});
diff --git a/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_docs_quick_start.js b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_docs_quick_start.js
new file mode 100644
index 0000000000..e58785379d
--- /dev/null
+++ b/definitions/npm/mongodb_v3.6.x/flow_v0.201.x-/test_mongodb_v3.6.x_docs_quick_start.js
@@ -0,0 +1,97 @@
+// @flow
+
+import { describe, it } from 'flow-typed-test';
+import { Db } from 'mongodb';
+
+// http://mongodb.github.io/node-mongodb-native/3.5/quick-start/quick-start/
+describe('Quick Start', () => {
+  it('connect', () => {
+    const MongoClient = require('mongodb').MongoClient;
+    const assert = require('assert');
+
+    // Connection URL
+    const url = 'mongodb://localhost:27017';
+
+    // Database Name
+    const dbName = 'myproject';
+
+    // Create a new MongoClient
+    const client = new MongoClient(url);
+
+    // Use connect method to connect to the Server
+    client.connect(function(err) {
+      assert.equal(null, err);
+      console.log("Connected successfully to server");
+
+      const db = client.db(dbName);
+
+      client.close();
+    });
+  });
+
+  it('insertDocuments', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Insert some documents
+    collection.insertMany([
+      {a : 1}, {a : 2}, {a : 3}
+    ], function(err, result) {
+      assert.equal(err, null);
+      assert.equal(3, result.result.n);
+      assert.equal(3, result.ops.length);
+      console.log("Inserted 3 documents into the collection");
+      callback();
+    });
+  });
+
+  it('findDocuments', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Find some documents
+    collection.find({'a': 3}).toArray(function(err, docs) {
+      assert.equal(err, null);
+      console.log("Found the following records");
+      console.log(docs);
+      callback();
+    });
+  });
+
+  it('updateDocument', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Update document where a is 2, set b equal to 1
+    collection.updateOne({ a : 2 }, { $set: { b : 1 } }, function(err, result) {
+      assert.equal(err, null);
+      assert.equal(1, result.result.n);
+      console.log("Updated the document with the field a equal to 2");
+      callback();
+    });
+  });
+
+  it('removeDocument', (db: typeof Db, callback: () => void) => {
+    const assert = require('assert');
+    // Get the documents collection
+    const collection = db.collection('documents');
+    // Delete document where a is 3
+    collection.deleteOne({ a : 3 }, function(err, result) {
+      assert.equal(err, null);
+      assert.equal(1, result.result.n);
+      console.log("Removed the document with the field a equal to 3");
+      callback();
+    });
+  });
+
+  it('indexCollection', (db: typeof Db, callback: () => void) => {
+    db.collection('documents').createIndex(
+      { "a": 1 },
+        null,
+        function(err, results) {
+          console.log(results);
+          callback();
+      }
+    );
+  });
+})
\ No newline at end of file
diff --git a/definitions/npm/nock_v10.x.x/flow_v0.104.x-/nock_v10.x.x.js b/definitions/npm/nock_v10.x.x/flow_v0.104.x-v0.200.x/nock_v10.x.x.js
similarity index 100%
rename from definitions/npm/nock_v10.x.x/flow_v0.104.x-/nock_v10.x.x.js
rename to definitions/npm/nock_v10.x.x/flow_v0.104.x-v0.200.x/nock_v10.x.x.js
diff --git a/definitions/npm/nock_v10.x.x/flow_v0.201.x-/nock_v10.x.x.js b/definitions/npm/nock_v10.x.x/flow_v0.201.x-/nock_v10.x.x.js
new file mode 100644
index 0000000000..c97b7d7d48
--- /dev/null
+++ b/definitions/npm/nock_v10.x.x/flow_v0.201.x-/nock_v10.x.x.js
@@ -0,0 +1,146 @@
+declare type $npm$nock$Path = string | RegExp | ((url: string) => boolean);
+declare type $npm$nock$Parameter =
+  | string
+  | RegExp
+  | Array<mixed>
+  | Object
+  | ((body: Object | Array<mixed>) => boolean);
+
+declare type $npm$nock$RecordedCall = {
+  scope: string,
+  method: string,
+  path: string,
+  body: any,
+  status: number,
+  response: any,
+  headers: Object,
+  reqheader: Object,
+  ...
+};
+
+declare class $npm$nock$Recorder {
+  rec(options?: {
+    dont_print?: boolean,
+    output_objects?: boolean,
+    enable_reqheaders_recording?: boolean,
+    logging?: (content: any) => any,
+    use_separator: boolean,
+    ...
+  }): void;
+  play(): $npm$nock$RecordedCall[];
+}
+
+declare type $npm$nock$InterceptorOptions = {
+  hostname: string,
+  path: string,
+  method: string,
+  proto: string,
+  ...
+};
+
+declare class $npm$nock$NockBack {
+  static (path: string, cb: (cb: Function) => any): void;
+  fixtures: string;
+  setMode(mode: string): void;
+}
+
+declare class $npm$nock$Nock {
+  static (
+    url: string | RegExp,
+    options?: {
+      reqheaders?: Object,
+      badheaders?: string[],
+      filteringScope?: (scope: string) => boolean,
+      allowUnmocked?: boolean,
+      ...
+    }
+  ): $npm$nock$Nock;
+  static restore(): void;
+  static cleanAll(): void;
+  static disableNetConnect(): void;
+  static enableNetConnect(path?: $npm$nock$Path): void;
+  static load(path: string): $npm$nock$RecordedCall[];
+  // TODO: type definitions
+  static definitions(path: string): any;
+  static define(nocks: any): any;
+  static removeInterceptor(
+    interceptor: $npm$nock$Nock | $Shape<$npm$nock$InterceptorOptions>
+  ): void;
+  static emitter: events$EventEmitter;
+  static recorder: $npm$nock$Recorder;
+  static back: $npm$nock$NockBack;
+  get(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  post(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  put(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  head(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  delete(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  patch(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  merge(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  query(query: Object | boolean | ((query: Object) => boolean)): this;
+  reply(
+    code: number,
+    data?:
+      | ((
+          uri: string,
+          body: mixed,
+          cb: (error: ?Error, result: mixed) => any
+        ) => mixed)
+      | mixed,
+    header?: Object
+  ): this;
+  reply(
+    fn: (
+      uri: string,
+      body: mixed,
+      cb: (error: ?Error, result: mixed) => any
+    ) => mixed
+  ): this;
+  replyWithFile(code: number, path: string): this;
+  replyWithError(error: mixed): this;
+  basicAuth(auth: {
+    user: string,
+    pass: string,
+    ...
+  }): this;
+  defaultReplyHeaders(header: { [key: string]: string | ((req: any, res: any, body: any) => any), ... }): this;
+  replyContentLength(): this;
+  replyDate(date?: Date): this;
+  intercept(
+    path: $npm$nock$Path,
+    verb: string,
+    parameter?: $npm$nock$Parameter,
+    options?: any
+  ): this;
+  times(number: number): this;
+  once(): this;
+  twice(): this;
+  thrice(): this;
+  delayBody(delay: number): this;
+  delayConnection(delay: number): this;
+  delay(delay: number | {
+    head: number,
+    body: number,
+    ...
+  }): this;
+  socketDelay(delay: number): this;
+  filtering$npm$nock$Path(path: RegExp, replace: string): this;
+  filtering$npm$nock$Path(fn: (path: string) => string): this;
+  filteringRequestBody(body: RegExp, replace: string): this;
+  filteringRequestBody(fn: (path: string) => string): this;
+  matchHeader(header: string, value: mixed | ((value: mixed) => boolean)): this;
+  optionally(optional?: boolean): this;
+  persist(): this;
+
+  done(): void;
+  isDone(): boolean;
+  static isDone(): boolean;
+  pendingMocks(): string[];
+  static pendingMocks(): string[];
+  activeMocks(): string[];
+  static activeMocks(): string[];
+  log(logFn: Function): this;
+}
+
+declare module 'nock' {
+  declare module.exports: typeof $npm$nock$Nock;
+}
diff --git a/definitions/npm/nock_v9.x.x/flow_v0.104.x-/nock_v9.x.x.js b/definitions/npm/nock_v9.x.x/flow_v0.104.x-v0.200.x/nock_v9.x.x.js
similarity index 100%
rename from definitions/npm/nock_v9.x.x/flow_v0.104.x-/nock_v9.x.x.js
rename to definitions/npm/nock_v9.x.x/flow_v0.104.x-v0.200.x/nock_v9.x.x.js
diff --git a/definitions/npm/nock_v9.x.x/flow_v0.201.x-/nock_v9.x.x.js b/definitions/npm/nock_v9.x.x/flow_v0.201.x-/nock_v9.x.x.js
new file mode 100644
index 0000000000..c923ce082b
--- /dev/null
+++ b/definitions/npm/nock_v9.x.x/flow_v0.201.x-/nock_v9.x.x.js
@@ -0,0 +1,148 @@
+import EventEmitter from "eventemitter";
+
+declare type $npm$nock$Path = string | RegExp | ((url: string) => boolean);
+declare type $npm$nock$Parameter =
+  | string
+  | RegExp
+  | Array<mixed>
+  | Object
+  | ((body: Object | Array<mixed>) => boolean);
+
+declare type $npm$nock$RecordedCall = {
+  scope: string,
+  method: string,
+  path: string,
+  body: any,
+  status: number,
+  response: any,
+  headers: Object,
+  reqheader: Object,
+  ...
+};
+
+declare class $npm$nock$Recorder {
+  rec(options?: {
+    dont_print?: boolean,
+    output_objects?: boolean,
+    enable_reqheaders_recording?: boolean,
+    logging?: (content: any) => any,
+    use_separator: boolean,
+    ...
+  }): void;
+  play(): $npm$nock$RecordedCall[];
+}
+
+declare type $npm$nock$InterceptorOptions = {
+  hostname: string,
+  path: string,
+  method: string,
+  proto: string,
+  ...
+};
+
+declare class $npm$nock$NockBack {
+  static (path: string, cb: (cb: Function) => any): void;
+  fixtures: string;
+  setMode(mode: string): void;
+}
+
+declare class $npm$nock$Nock {
+  static (
+    url: string | RegExp,
+    options?: {
+      reqheaders?: Object,
+      badheaders?: string[],
+      filteringScope?: (scope: string) => boolean,
+      allowUnmocked?: boolean,
+      ...
+    }
+  ): $npm$nock$Nock;
+  static restore(): void;
+  static cleanAll(): void;
+  static disableNetConnect(): void;
+  static enableNetConnect(path?: $npm$nock$Path): void;
+  static load(path: string): $npm$nock$RecordedCall[];
+  // TODO: type definitions
+  static definitions(path: string): any;
+  static define(nocks: any): any;
+  static removeInterceptor(
+    interceptor: $npm$nock$Nock | $Shape<$npm$nock$InterceptorOptions>
+  ): void;
+  static emitter: EventEmitter;
+  static recorder: $npm$nock$Recorder;
+  static back: $npm$nock$NockBack;
+  get(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  post(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  put(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  head(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  delete(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  patch(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  merge(path: $npm$nock$Path, parameter?: $npm$nock$Parameter): this;
+  query(query: Object | boolean | ((query: Object) => boolean)): this;
+  reply(
+    code: number,
+    data?:
+      | ((
+          uri: string,
+          body: mixed,
+          cb: (error: ?Error, result: mixed) => any
+        ) => mixed)
+      | mixed,
+    header?: Object
+  ): this;
+  reply(
+    fn: (
+      uri: string,
+      body: mixed,
+      cb: (error: ?Error, result: mixed) => any
+    ) => mixed
+  ): this;
+  replyWithFile(code: number, path: string): this;
+  replyWithError(error: mixed): this;
+  basicAuth(auth: {
+    user: string,
+    pass: string,
+    ...
+  }): this;
+  defaultReplyHeaders(header: { [key: string]: string | ((req: any, res: any, body: any) => any), ... }): this;
+  replyContentLength(): this;
+  replyDate(date?: Date): this;
+  intercept(
+    path: $npm$nock$Path,
+    verb: string,
+    parameter?: $npm$nock$Parameter,
+    options?: any
+  ): this;
+  times(number: number): this;
+  once(): this;
+  twice(): this;
+  thrice(): this;
+  delayBody(delay: number): this;
+  delayConnection(delay: number): this;
+  delay(delay: number | {
+    head: number,
+    body: number,
+    ...
+  }): this;
+  socketDelay(delay: number): this;
+  filteringPath(path: RegExp, replace: string): this;
+  filteringPath(fn: (path: string) => string): this;
+  filteringRequestBody(body: RegExp, replace: string): this;
+  filteringRequestBody(fn: (path: string) => string): this;
+  matchHeader(header: string, value: mixed | ((value: mixed) => boolean)): this;
+  optionally(): this;
+  persist(): this;
+
+  done(): void;
+  isDone(): boolean;
+  static isDone(): boolean;
+  pendingMocks(): string[];
+  static pendingMocks(): string[];
+  activeMocks(): string[];
+  static activeMocks(): string[];
+  log(logFn: Function): this;
+}
+
+declare module "nock" {
+  declare module.exports: typeof $npm$nock$Nock;
+}
diff --git a/definitions/npm/pell_v1.x.x/flow_v0.104.x-/pell_v1.x.x.js b/definitions/npm/pell_v1.x.x/flow_v0.104.x-v0.200.x/pell_v1.x.x.js
similarity index 100%
rename from definitions/npm/pell_v1.x.x/flow_v0.104.x-/pell_v1.x.x.js
rename to definitions/npm/pell_v1.x.x/flow_v0.104.x-v0.200.x/pell_v1.x.x.js
diff --git a/definitions/npm/pell_v1.x.x/flow_v0.201.x-/pell_v1.x.x.js b/definitions/npm/pell_v1.x.x/flow_v0.201.x-/pell_v1.x.x.js
new file mode 100644
index 0000000000..e6e60f0309
--- /dev/null
+++ b/definitions/npm/pell_v1.x.x/flow_v0.201.x-/pell_v1.x.x.js
@@ -0,0 +1,99 @@
+declare module 'pell' {
+  declare type DefaultAction =
+    | 'bold'
+    | 'italic'
+    | 'underline'
+    | 'strikethrough'
+    | 'heading1'
+    | 'heading2'
+    | 'paragraph'
+    | 'quote'
+    | 'olist'
+    | 'ulist'
+    | 'code'
+    | 'line'
+    | 'link'
+    | 'image';
+
+  declare type CustomAction = {|
+    /**
+     * Only required if overwriting
+     */
+    name?: DefaultAction,
+    /**
+     * Optional if overwriting, required if custom action
+     */
+    icon?: string,
+    title?: string,
+    /**
+     * Only required if custom action.
+     * Returns a Boolean that is false if the command is unsupported or disabled.
+     */
+    result?: () => boolean,
+    state?: () => boolean,
+  |};
+
+  declare type Action = DefaultAction | CustomAction;
+
+  declare type ClassNames = $Shape<{|
+    actionbar: string,
+    button: string,
+    content: string,
+    selected: string,
+  |}>;
+
+  declare type Options = {|
+    /**
+     * <HTMLElement>, required
+     */
+    element: HTMLElement,
+    /**
+     * Use the output html, triggered by element's `oninput` event
+     */
+    onChange: (html: string) => void,
+    /**
+     * default = 'div'
+     * Instructs the editor which element to inject via the return key
+     */
+    defaultParagraphSeparator?: string,
+    /**
+     * default = false
+     * Outputs <span style="font-weight: bold;"></span> instead of <b></b>
+     */
+    styleWithCSS?: boolean,
+    /**
+     * Specify the actions you specifically want (in order)
+     */
+    actions?: Array<Action>,
+    /**
+     * Choose your custom class names
+     */
+    classes?: ClassNames,
+  |};
+
+  declare type Element = HTMLElement & { content: HTMLElement, ... };
+
+  /**
+   * Execute a document command, see reference:
+   * https://developer.mozilla.org/en/docs/Web/API/Document/execCommand
+   * this is just `document.execCommand(command, false, value)`
+   */
+  declare type Exec = (command: string, value?: string) => void;
+
+  declare type Init = (Options) => Element;
+
+  declare export var exec: Exec;
+  declare export var init: Init;
+  declare export default {|
+    exec: Exec,
+    init: Init,
+  |};
+}
+
+declare module 'pell/dist/pell' {
+  declare module.exports: $Exports<'pell'>;
+}
+
+declare module 'pell/dist/pell.js' {
+  declare module.exports: $Exports<'pell'>;
+}
diff --git a/definitions/npm/pg_v6.x.x/flow_v0.104.x-/pg_v6.x.x.js b/definitions/npm/pg_v6.x.x/flow_v0.104.x-v0.200.x/pg_v6.x.x.js
similarity index 100%
rename from definitions/npm/pg_v6.x.x/flow_v0.104.x-/pg_v6.x.x.js
rename to definitions/npm/pg_v6.x.x/flow_v0.104.x-v0.200.x/pg_v6.x.x.js
diff --git a/definitions/npm/pg_v6.x.x/flow_v0.201.x-/pg_v6.x.x.js b/definitions/npm/pg_v6.x.x/flow_v0.201.x-/pg_v6.x.x.js
new file mode 100644
index 0000000000..bc006a4592
--- /dev/null
+++ b/definitions/npm/pg_v6.x.x/flow_v0.201.x-/pg_v6.x.x.js
@@ -0,0 +1,299 @@
+declare module 'pg' {
+  // Note: Currently There are some issues in Function overloading.
+  // https://github.com/facebook/flow/issues/2423
+  // So i temporarily remove the
+  // `((event: string, listener: Function) => EventEmitter );`
+  // from all overloading for EventEmitter.on().
+
+  // `any` types exised in this file, cause of currently `mixed` did not work well
+  // in Function Overloading.
+
+  // `Function` types exised in this file, cause of they come from another
+  // untyped npm lib.
+
+  /* Cause of <flow 0.36 did not support export type very well,
+  // so copy the types from pg-pool
+  // https://github.com/flowtype/flow-typed/issues/16
+  // https://github.com/facebook/flow/commit/843389f89c69516506213e298096a14867a45061
+  const Pool = require('pg-pool');
+  import type {
+    PgPoolConfig,
+    PoolConnectCallback,
+    DoneCallback,
+    PoolClient
+  } from 'pg-pool';
+  */
+
+  // ------------- copy from 'pg-pool' ------------>>
+  /*
+   * PgPoolConfig's properties are passed unchanged to both
+   * the node-postgres Client constructor and the node-pool constructor
+   * allowing you to fully configure the behavior of both
+   * node-pool (https://github.com/coopernurse/node-pool)
+  */
+  declare type PgPoolConfig = {
+    // node-pool ----------------
+    name: string,
+    create: Function,
+    destroy: Function,
+    max: number,
+    min: number,
+    refreshIdle: boolean,
+    idleTimeoutMillis: number,
+    reapIntervalMillis: number,
+    returnToHead: boolean,
+    priorityRange: number,
+    validate: Function,
+    validateAsync: Function,
+    log: Function,
+    // node-postgres Client ------
+    //database user's name
+    user: string,
+    //name of database to connect
+    database: string,
+    //database user's password
+    password: string,
+    //database port
+    port: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean,
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    // pg-pool
+    Client: mixed,
+    Promise: mixed,
+    onCreate: Function,
+    ...
+  };
+
+  /*
+   * Not extends from Client, cause some of Client's functions(ex: connect and end)
+   * should not be used by PoolClient (which returned from Pool.connect).
+  */
+  declare type PoolClient = {
+    release(error?: mixed): void,
+    query:
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query ),
+    on:
+    ((event: 'drain', listener: () => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+    ((event: 'notification', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'notice', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'end', listener: () => void) => events$EventEmitter ),
+    ...
+  }
+
+  declare type PoolConnectCallback = (error: PG_ERROR|null,
+    client: PoolClient|null, done: DoneCallback) => void;
+  declare type DoneCallback = (error?: mixed) => void;
+  // https://github.com/facebook/flow/blob/master/lib/node.js#L581
+  // on() returns a events$EventEmitter
+  declare class Pool extends events$EventEmitter {
+    constructor(options: $Shape<PgPoolConfig>, Client?: Class<Client>): void;
+    connect(cb?: PoolConnectCallback): Promise<PoolClient>;
+    take(cb?: PoolConnectCallback): Promise<PoolClient>;
+    end(cb?: DoneCallback): Promise<void>;
+
+  // Note: not like the pg's Client, the Pool.query return a Promise,
+  // not a Thenable Query which Client returned.
+  // And there is a flow(<0.34) issue here, when Array<mixed>,
+  // the overloading will not work
+    query:
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Promise<ResultSet> ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Promise<ResultSet>);
+
+    /* flow issue: https://github.com/facebook/flow/issues/2423
+     * When this fixed, this overloading can be used.
+    */
+    /*
+      on:
+      ((event: 'connect', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: 'acquire', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: "error", listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+      ((event: string, listener: Function) => events$EventEmitter);
+    */
+  }
+
+  // <<------------- copy from 'pg-pool' ------------------------------
+
+
+  // error
+  declare type PG_ERROR = {
+    name: string,
+    length: number,
+    severity: string,
+    code: string,
+    detail: string|void,
+    hint: string|void,
+    position: string|void,
+    internalPosition: string|void,
+    internalQuery: string|void,
+    where: string|void,
+    schema: string|void,
+    table: string|void,
+    column: string|void,
+    dataType: string|void,
+    constraint: string|void,
+    file: string|void,
+    line: string|void,
+    routine: string|void,
+    ...
+  };
+
+  declare type ClientConfig = {
+    //database user's name
+    user?: string,
+    //name of database to connect
+    database?: string,
+    //database user's password
+    password?: string,
+    //database port
+    port?: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean,
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    ...
+  }
+
+  declare type Row = { [key: string]: mixed, ... };
+  declare type ResultSet = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    ...
+  };
+  declare type ResultBuilder = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    addRow: (row: Row) => void,
+    ...
+  };
+  declare type QueryConfig = {
+    name?: string,
+    text: string,
+    values?: any[],
+    ...
+  };
+
+  declare type QueryCallback = (err: PG_ERROR|null, result: ResultSet|void) => void;
+  declare type ClientConnectCallback = (err: PG_ERROR|null, client: Client|void) => void;
+
+  /*
+   * lib/query.js
+   * Query extends from EventEmitter in source code.
+   * but in Flow there is no multiple extends.
+   * And in Flow await is a `declare function $await<T>(p: Promise<T> | T): T;`
+   * seems can not resolve a Thenable's value type directly
+   * so `Query extends Promise` to make thing temporarily work.
+   * like this:
+   * const q = client.query('select * from some');
+   * q.on('row',cb); // Event
+   * const result = await q; // or await
+   *
+   * ToDo: should find a better way.
+  */
+  declare class Query extends Promise<ResultSet> {
+    then<U>(
+      onFulfill?: ?((value: ResultSet) => Promise<U> | U),
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+    // Because then and catch return a Promise,
+    // .then.catch will lose catch's type information PG_ERROR.
+    catch<U>(
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+
+    on :
+    ((event: 'row', listener: (row: Row, result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'end', listener: (result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter );
+  }
+
+  /*
+   * lib/client.js
+   * Note: not extends from EventEmitter, for This Type returned by on().
+   * Flow's EventEmitter force return a EventEmitter in on().
+   * ToDo: Not sure in on() if return events$EventEmitter or this will be more suitable
+   * return this will restrict event to given literial when chain on().on().on().
+   * return a events$EventEmitter will fallback to raw EventEmitter, when chains
+  */
+  declare class Client {
+    constructor(config?: string | ClientConfig): void;
+    connect(callback?: ClientConnectCallback):void;
+    end(): void;
+
+    escapeLiteral(str: string): string;
+    escapeIdentifier(str: string): string;
+
+    query:
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query );
+
+    on:
+    ((event: 'drain', listener: () => void) => this )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => this )&
+    ((event: 'notification', listener: (message: any) => void) => this )&
+    ((event: 'notice', listener: (message: any) => void) => this )&
+    ((event: 'end', listener: () => void) => this );
+  }
+
+  /*
+   * require('pg-types')
+  */
+  declare type TypeParserText = (value: string) => any;
+  declare type TypeParserBinary = (value: Buffer) => any;
+  declare type Types = {
+    getTypeParser:
+      ((oid: number, format?: 'text') => TypeParserText )&
+      ((oid: number, format: 'binary') => TypeParserBinary ),
+    setTypeParser:
+      ((oid: number, format?: 'text', parseFn: TypeParserText) => void )&
+      ((oid: number, format: 'binary', parseFn: TypeParserBinary) => void)&
+      ((oid: number, parseFn: TypeParserText) => void),
+    ...
+  }
+
+  /*
+   * lib/index.js ( class PG)
+  */
+  declare class PG extends events$EventEmitter {
+    types: Types;
+    Client: Class<Client>;
+    Pool: Class<Pool>;
+    Connection: mixed; //Connection is used internally by the Client.
+    constructor(client: Client): void;
+    native: {
+      // native binding, have the same capability like PG
+      types: Types,
+      Client: Class<Client>,
+      Pool: Class<Pool>,
+      Connection: mixed,
+      ...
+    };
+  // The end(),connect(),cancel() in PG is abandoned ?
+  }
+
+  // These class are not exposed by pg.
+  declare type PoolType = Pool;
+  declare type PGType = PG;
+  declare type QueryType = Query;
+  // module export, keep same structure with index.js
+  declare module.exports: PG;
+}
diff --git a/definitions/npm/pg_v7.x.x/flow_v0.104.x-/pg_v7.x.x.js b/definitions/npm/pg_v7.x.x/flow_v0.104.x-v0.200.x/pg_v7.x.x.js
similarity index 100%
rename from definitions/npm/pg_v7.x.x/flow_v0.104.x-/pg_v7.x.x.js
rename to definitions/npm/pg_v7.x.x/flow_v0.104.x-v0.200.x/pg_v7.x.x.js
diff --git a/definitions/npm/pg_v7.x.x/flow_v0.201.x-/pg_v7.x.x.js b/definitions/npm/pg_v7.x.x/flow_v0.201.x-/pg_v7.x.x.js
new file mode 100644
index 0000000000..acc3d6a38c
--- /dev/null
+++ b/definitions/npm/pg_v7.x.x/flow_v0.201.x-/pg_v7.x.x.js
@@ -0,0 +1,308 @@
+declare module 'pg' {
+  // Note: Currently There are some issues in Function overloading.
+  // https://github.com/facebook/flow/issues/2423
+  // So i temporarily remove the
+  // `((event: string, listener: Function) => EventEmitter );`
+  // from all overloading for EventEmitter.on().
+
+  // `any` types exised in this file, cause of currently `mixed` did not work well
+  // in Function Overloading.
+
+  // `Function` types exised in this file, cause of they come from another
+  // untyped npm lib.
+
+  /* Cause of <flow 0.36 did not support export type very well,
+  // so copy the types from pg-pool
+  // https://github.com/flowtype/flow-typed/issues/16
+  // https://github.com/facebook/flow/commit/843389f89c69516506213e298096a14867a45061
+  const Pool = require('pg-pool');
+  import type {
+    PgPoolConfig,
+    PoolConnectCallback,
+    DoneCallback,
+    PoolClient
+  } from 'pg-pool';
+  */
+
+  // ------------- copy from 'pg-pool' ------------>>
+  /*
+   * PgPoolConfig's properties are passed unchanged to both
+   * the node-postgres Client constructor and the node-pool constructor
+   * allowing you to fully configure the behavior of both
+   * node-pool (https://github.com/coopernurse/node-pool)
+  */
+  declare type PgPoolConfig = {
+    // node-pool ----------------
+    name: string,
+    create: Function,
+    destroy: Function,
+    max: number,
+    min: number,
+    refreshIdle: boolean,
+    idleTimeoutMillis: number,
+    connectionTimeoutMillis: number,
+    reapIntervalMillis: number,
+    returnToHead: boolean,
+    priorityRange: number,
+    validate: Function,
+    validateAsync: Function,
+    log: Function,
+    // node-postgres Client ------
+    //database connection string to define some other config parameters
+    connectionString: string,
+    //database user's name
+    user: string,
+    //name of database to connect
+    database: string,
+    //database user's password
+    password: string,
+    //database port
+    port: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean,
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    // max milliseconds any query using this connection will execute for before timing out in error. false=unlimited
+    // default value: false
+    statement_timeout?: boolean | number,
+    // pg-pool
+    Client: mixed,
+    Promise: mixed,
+    onCreate: Function,
+    ...
+  };
+
+  /*
+   * Not extends from Client, cause some of Client's functions(ex: connect and end)
+   * should not be used by PoolClient (which returned from Pool.connect).
+  */
+  declare type PoolClient = {
+    release(error?: mixed): void,
+    query:
+    ( <T: QuerySubmittableConfig>(query: T, callback?: QueryCallback) => T ) &
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query ),
+    on:
+    ((event: 'drain', listener: () => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+    ((event: 'notification', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'notice', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'end', listener: () => void) => events$EventEmitter ),
+    ...
+  }
+
+  declare type PoolConnectCallback = (error: PG_ERROR|null,
+    client: PoolClient|null, done: DoneCallback) => void;
+  declare type DoneCallback = (error?: mixed) => void;
+  // https://github.com/facebook/flow/blob/master/lib/node.js#L581
+  // on() returns a events$EventEmitter
+  declare class Pool extends events$EventEmitter {
+    constructor(options: $Shape<PgPoolConfig>, Client?: Class<Client>): void;
+    connect(cb?: PoolConnectCallback): Promise<PoolClient>;
+    take(cb?: PoolConnectCallback): Promise<PoolClient>;
+    end(cb?: DoneCallback): Promise<void>;
+
+  // Note: not like the pg's Client, the Pool.query return a Promise,
+  // not a Thenable Query which Client returned.
+  // And there is a flow(<0.34) issue here, when Array<mixed>,
+  // the overloading will not work
+    query:
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Promise<ResultSet> ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Promise<ResultSet>);
+
+    /* flow issue: https://github.com/facebook/flow/issues/2423
+     * When this fixed, this overloading can be used.
+    */
+    /*
+      on:
+      ((event: 'connect', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: 'acquire', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: "error", listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+      ((event: string, listener: Function) => events$EventEmitter);
+    */
+  }
+
+  // <<------------- copy from 'pg-pool' ------------------------------
+
+
+  // error
+  declare type PG_ERROR = {
+    name: string,
+    length: number,
+    severity: string,
+    code: string,
+    detail: string|void,
+    hint: string|void,
+    position: string|void,
+    internalPosition: string|void,
+    internalQuery: string|void,
+    where: string|void,
+    schema: string|void,
+    table: string|void,
+    column: string|void,
+    dataType: string|void,
+    constraint: string|void,
+    file: string|void,
+    line: string|void,
+    routine: string|void,
+    ...
+  };
+
+  declare type ClientConfig = {
+    //database user's name
+    user?: string,
+    //name of database to connect
+    database?: string,
+    //database user's password
+    password?: string,
+    //database port
+    port?: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean,
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    ...
+  }
+
+  declare type Row = { [key: string]: mixed, ... };
+  declare type ResultSet = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    ...
+  };
+  declare type ResultBuilder = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    addRow: (row: Row) => void,
+    ...
+  };
+  declare type QueryConfig = {
+    name?: string,
+    text: string,
+    values?: any[],
+    ...
+  };
+  declare type QuerySubmittableConfig = QueryConfig & { submit: (connection: mixed) => void, ... };
+
+  declare type QueryCallback = (err: PG_ERROR|null, result: ResultSet|void) => void;
+  declare type ClientConnectCallback = (err: PG_ERROR|null, client: Client|void) => void;
+
+  /*
+   * lib/query.js
+   * Query extends from EventEmitter in source code.
+   * but in Flow there is no multiple extends.
+   * And in Flow await is a `declare function $await<T>(p: Promise<T> | T): T;`
+   * seems can not resolve a Thenable's value type directly
+   * so `Query extends Promise` to make thing temporarily work.
+   * like this:
+   * const q = client.query('select * from some');
+   * q.on('row',cb); // Event
+   * const result = await q; // or await
+   *
+   * ToDo: should find a better way.
+  */
+  declare class Query extends Promise<ResultSet> {
+    then<U>(
+      onFulfill?: ?((value: ResultSet) => Promise<U> | U),
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+    // Because then and catch return a Promise,
+    // .then.catch will lose catch's type information PG_ERROR.
+    catch<U>(
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+
+    on :
+    ((event: 'row', listener: (row: Row, result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'end', listener: (result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter );
+  }
+
+  /*
+   * lib/client.js
+   * Note: not extends from EventEmitter, for This Type returned by on().
+   * Flow's EventEmitter force return a EventEmitter in on().
+   * ToDo: Not sure in on() if return events$EventEmitter or this will be more suitable
+   * return this will restrict event to given literial when chain on().on().on().
+   * return a events$EventEmitter will fallback to raw EventEmitter, when chains
+  */
+  declare class Client {
+    constructor(config?: string | ClientConfig): void;
+    connect(callback?: ClientConnectCallback):void;
+    end(): void;
+
+    escapeLiteral(str: string): string;
+    escapeIdentifier(str: string): string;
+
+    query:
+    ( <T: QuerySubmittableConfig>(query: T, callback?: QueryCallback) => T ) &
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query );
+
+    on:
+    ((event: 'drain', listener: () => void) => this )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => this )&
+    ((event: 'notification', listener: (message: any) => void) => this )&
+    ((event: 'notice', listener: (message: any) => void) => this )&
+    ((event: 'end', listener: () => void) => this );
+  }
+
+  /*
+   * require('pg-types')
+  */
+  declare type TypeParserText = (value: string) => any;
+  declare type TypeParserBinary = (value: Buffer) => any;
+  declare type Types = {
+    getTypeParser:
+      ((oid: number, format?: 'text') => TypeParserText )&
+      ((oid: number, format: 'binary') => TypeParserBinary ),
+    setTypeParser:
+      ((oid: number, format?: 'text', parseFn: TypeParserText) => void )&
+      ((oid: number, format: 'binary', parseFn: TypeParserBinary) => void)&
+      ((oid: number, parseFn: TypeParserText) => void),
+    ...
+  }
+
+  /*
+   * lib/index.js ( class PG)
+  */
+  declare class PG extends events$EventEmitter {
+    types: Types;
+    Client: Class<Client>;
+    Pool: Class<Pool>;
+    Connection: mixed; //Connection is used internally by the Client.
+    constructor(client: Client): void;
+    native: {
+      // native binding, have the same capability like PG
+      types: Types,
+      Client: Class<Client>,
+      Pool: Class<Pool>,
+      Connection: mixed,
+      ...
+    };
+  // The end(),connect(),cancel() in PG is abandoned ?
+  }
+
+  // These class are not exposed by pg.
+  declare type PoolType = Pool;
+  declare type PGType = PG;
+  declare type QueryType = Query;
+  // module export, keep same structure with index.js
+  declare module.exports: PG;
+}
diff --git a/definitions/npm/pg_v8.x.x/flow_v0.83.x-/pg_v8.x.x.js b/definitions/npm/pg_v8.x.x/flow_v0.201.x-/pg_v8.x.x.js
similarity index 100%
rename from definitions/npm/pg_v8.x.x/flow_v0.83.x-/pg_v8.x.x.js
rename to definitions/npm/pg_v8.x.x/flow_v0.201.x-/pg_v8.x.x.js
diff --git a/definitions/npm/pg_v8.x.x/flow_v0.83.x-/test_pg_v8.x.x.js b/definitions/npm/pg_v8.x.x/flow_v0.201.x-/test_pg_v8.x.x.js
similarity index 100%
rename from definitions/npm/pg_v8.x.x/flow_v0.83.x-/test_pg_v8.x.x.js
rename to definitions/npm/pg_v8.x.x/flow_v0.201.x-/test_pg_v8.x.x.js
diff --git a/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/pg_v8.x.x.js b/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/pg_v8.x.x.js
new file mode 100644
index 0000000000..945f0c5fa4
--- /dev/null
+++ b/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/pg_v8.x.x.js
@@ -0,0 +1,308 @@
+declare module 'pg' {
+  // Note: Currently There are some issues in Function overloading.
+  // https://github.com/facebook/flow/issues/2423
+  // So i temporarily remove the
+  // `((event: string, listener: Function) => EventEmitter );`
+  // from all overloading for EventEmitter.on().
+
+  // `any` types exised in this file, cause of currently `mixed` did not work well
+  // in Function Overloading.
+
+  // `Function` types exised in this file, cause of they come from another
+  // untyped npm lib.
+
+  /* Cause of <flow 0.36 did not support export type very well,
+  // so copy the types from pg-pool
+  // https://github.com/flowtype/flow-typed/issues/16
+  // https://github.com/facebook/flow/commit/843389f89c69516506213e298096a14867a45061
+  const Pool = require('pg-pool');
+  import type {
+    PgPoolConfig,
+    PoolConnectCallback,
+    DoneCallback,
+    PoolClient
+  } from 'pg-pool';
+  */
+
+  // ------------- copy from 'pg-pool' ------------>>
+  /*
+   * PgPoolConfig's properties are passed unchanged to both
+   * the node-postgres Client constructor and the node-pool constructor
+   * allowing you to fully configure the behavior of both
+   * node-pool (https://github.com/coopernurse/node-pool)
+  */
+  declare type PgPoolConfig = {
+    // node-pool ----------------
+    name: string,
+    create: Function,
+    destroy: Function,
+    max: number,
+    min: number,
+    refreshIdle: boolean,
+    idleTimeoutMillis: number,
+    connectionTimeoutMillis: number,
+    reapIntervalMillis: number,
+    returnToHead: boolean,
+    priorityRange: number,
+    validate: Function,
+    validateAsync: Function,
+    log: Function,
+    // node-postgres Client ------
+    //database connection string to define some other config parameters
+    connectionString: string,
+    //database user's name
+    user: string,
+    //name of database to connect
+    database: string,
+    //database user's password
+    password: string,
+    //database port
+    port: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean | { rejectUnauthorized: boolean, ... },
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    // max milliseconds any query using this connection will execute for before timing out in error. false=unlimited
+    // default value: false
+    statement_timeout?: boolean | number,
+    // pg-pool
+    Client: mixed,
+    Promise: mixed,
+    onCreate: Function,
+    ...
+  };
+
+  /*
+   * Not extends from Client, cause some of Client's functions(ex: connect and end)
+   * should not be used by PoolClient (which returned from Pool.connect).
+  */
+  declare type PoolClient = {
+    release(error?: mixed): void,
+    query:
+    ( <T: QuerySubmittableConfig>(query: T, callback?: QueryCallback) => T ) &
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query ),
+    on:
+    ((event: 'drain', listener: () => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+    ((event: 'notification', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'notice', listener: (message: any) => void) => events$EventEmitter )&
+    ((event: 'end', listener: () => void) => events$EventEmitter ),
+    ...
+  }
+
+  declare type PoolConnectCallback = (error: PG_ERROR|null,
+    client: PoolClient|null, done: DoneCallback) => void;
+  declare type DoneCallback = (error?: mixed) => void;
+  // https://github.com/facebook/flow/blob/master/lib/node.js#L581
+  // on() returns a events$EventEmitter
+  declare class Pool extends events$EventEmitter {
+    constructor(options: $Shape<PgPoolConfig>, Client?: Class<Client>): void;
+    connect(cb?: PoolConnectCallback): Promise<PoolClient>;
+    take(cb?: PoolConnectCallback): Promise<PoolClient>;
+    end(cb?: DoneCallback): Promise<void>;
+
+  // Note: not like the pg's Client, the Pool.query return a Promise,
+  // not a Thenable Query which Client returned.
+  // And there is a flow(<0.34) issue here, when Array<mixed>,
+  // the overloading will not work
+    query:
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Promise<ResultSet> ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Promise<ResultSet>);
+
+    /* flow issue: https://github.com/facebook/flow/issues/2423
+     * When this fixed, this overloading can be used.
+    */
+    /*
+      on:
+      ((event: 'connect', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: 'acquire', listener: (client: PoolClient) => void) => events$EventEmitter )&
+      ((event: "error", listener: (err: PG_ERROR) => void) => events$EventEmitter )&
+      ((event: string, listener: Function) => events$EventEmitter);
+    */
+  }
+
+  // <<------------- copy from 'pg-pool' ------------------------------
+
+
+  // error
+  declare type PG_ERROR = {
+    name: string,
+    length: number,
+    severity: string,
+    code: string,
+    detail: string|void,
+    hint: string|void,
+    position: string|void,
+    internalPosition: string|void,
+    internalQuery: string|void,
+    where: string|void,
+    schema: string|void,
+    table: string|void,
+    column: string|void,
+    dataType: string|void,
+    constraint: string|void,
+    file: string|void,
+    line: string|void,
+    routine: string|void,
+    ...
+  };
+
+  declare type ClientConfig = {
+    //database user's name
+    user?: string,
+    //name of database to connect
+    database?: string,
+    //database user's password
+    password?: string,
+    //database port
+    port?: number,
+    // database host. defaults to localhost
+    host?: string,
+    // whether to try SSL/TLS to connect to server. default value: false
+    ssl?: boolean | { rejectUnauthorized: boolean, ... },
+    // name displayed in the pg_stat_activity view and included in CSV log entries
+    // default value: process.env.PGAPPNAME
+    application_name?: string,
+    // fallback value for the application_name configuration parameter
+    // default value: false
+    fallback_application_name?: string,
+    ...
+  }
+
+  declare type Row = { [key: string]: mixed, ... };
+  declare type ResultSet = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    ...
+  };
+  declare type ResultBuilder = {
+    command: string,
+    rowCount: number,
+    oid: number,
+    rows: Array<Row>,
+    addRow: (row: Row) => void,
+    ...
+  };
+  declare type QueryConfig = {
+    name?: string,
+    text: string,
+    values?: any[],
+    ...
+  };
+  declare type QuerySubmittableConfig = QueryConfig & { submit: (connection: mixed) => void, ... };
+
+  declare type QueryCallback = (err: PG_ERROR|null, result: ResultSet|void) => void;
+  declare type ClientConnectCallback = (err: PG_ERROR|null, client: Client|void) => void;
+
+  /*
+   * lib/query.js
+   * Query extends from EventEmitter in source code.
+   * but in Flow there is no multiple extends.
+   * And in Flow await is a `declare function $await<T>(p: Promise<T> | T): T;`
+   * seems can not resolve a Thenable's value type directly
+   * so `Query extends Promise` to make thing temporarily work.
+   * like this:
+   * const q = client.query('select * from some');
+   * q.on('row',cb); // Event
+   * const result = await q; // or await
+   *
+   * ToDo: should find a better way.
+  */
+  declare class Query extends Promise<ResultSet> {
+    then<U>(
+      onFulfill?: ?((value: ResultSet) => Promise<U> | U),
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+    // Because then and catch return a Promise,
+    // .then.catch will lose catch's type information PG_ERROR.
+    catch<U>(
+      onReject?: ?((error: PG_ERROR) => Promise<U> | U)
+    ): Promise<U>;
+
+    on :
+    ((event: 'row', listener: (row: Row, result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'end', listener: (result: ResultBuilder) => void) => events$EventEmitter )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => events$EventEmitter );
+  }
+
+  /*
+   * lib/client.js
+   * Note: not extends from EventEmitter, for This Type returned by on().
+   * Flow's EventEmitter force return a EventEmitter in on().
+   * ToDo: Not sure in on() if return events$EventEmitter or this will be more suitable
+   * return this will restrict event to given literial when chain on().on().on().
+   * return a events$EventEmitter will fallback to raw EventEmitter, when chains
+  */
+  declare class Client {
+    constructor(config?: string | ClientConfig): void;
+    connect(callback?: ClientConnectCallback):void;
+    end(): void;
+
+    escapeLiteral(str: string): string;
+    escapeIdentifier(str: string): string;
+
+    query:
+    ( <T: QuerySubmittableConfig>(query: T, callback?: QueryCallback) => T ) &
+    ( (query: QueryConfig|string, callback?: QueryCallback) => Query ) &
+    ( (text: string, values: Array<any>, callback?: QueryCallback) => Query );
+
+    on:
+    ((event: 'drain', listener: () => void) => this )&
+    ((event: 'error', listener: (err: PG_ERROR) => void) => this )&
+    ((event: 'notification', listener: (message: any) => void) => this )&
+    ((event: 'notice', listener: (message: any) => void) => this )&
+    ((event: 'end', listener: () => void) => this );
+  }
+
+  /*
+   * require('pg-types')
+  */
+  declare type TypeParserText = (value: string) => any;
+  declare type TypeParserBinary = (value: Buffer) => any;
+  declare type Types = {
+    getTypeParser:
+      ((oid: number, format?: 'text') => TypeParserText )&
+      ((oid: number, format: 'binary') => TypeParserBinary ),
+    setTypeParser:
+      ((oid: number, format?: 'text', parseFn: TypeParserText) => void )&
+      ((oid: number, format: 'binary', parseFn: TypeParserBinary) => void)&
+      ((oid: number, parseFn: TypeParserText) => void),
+    ...
+  }
+
+  /*
+   * lib/index.js ( class PG)
+  */
+  declare class PG extends events$EventEmitter {
+    types: Types;
+    Client: Class<Client>;
+    Pool: Class<Pool>;
+    Connection: mixed; //Connection is used internally by the Client.
+    constructor(client: Client): void;
+    native: {
+      // native binding, have the same capability like PG
+      types: Types,
+      Client: Class<Client>,
+      Pool: Class<Pool>,
+      Connection: mixed,
+      ...
+    };
+  // The end(),connect(),cancel() in PG is abandoned ?
+  }
+
+  // These class are not exposed by pg.
+  declare type PoolType = Pool;
+  declare type PGType = PG;
+  declare type QueryType = Query;
+  // module export, keep same structure with index.js
+  declare module.exports: PG;
+}
diff --git a/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/test_pg_v8.x.x.js b/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/test_pg_v8.x.x.js
new file mode 100644
index 0000000000..1e314e9215
--- /dev/null
+++ b/definitions/npm/pg_v8.x.x/flow_v0.83.x-v0.200.x/test_pg_v8.x.x.js
@@ -0,0 +1,226 @@
+// @flow
+import pg from 'pg';
+import type {
+  ResultSet,
+  ResultBuilder,
+  QueryType,
+  QuerySubmittableConfig,
+  PG_ERROR,
+  Client,
+  Row,
+  DoneCallback,
+  PoolClient,
+  Pool,
+  PGType
+} from 'pg';
+
+pg.types.setTypeParser(1184, v => v);
+pg.types.setTypeParser(1184, 'text', (v: string) => v);
+// $FlowExpectedError[incompatible-call]
+pg.types.setTypeParser(1184, 'binary', (v: string) => v)
+pg.types.setTypeParser(1184, 'binary', (v: Buffer) => v)
+// $FlowExpectedError[incompatible-call]
+pg.types.setTypeParser(1184, (v: Buffer) => v)
+
+// There are two common ways to use node-postgres.
+function test_pg() {
+  // 1. interact with your server via a pool of clients
+  function test_pool(pool: Pool) {
+    // 1.1 you can run queries directly against the pool
+    const rq: Promise<ResultSet> = pool.query('select * from table;');
+    // $FlowExpectedError[incompatible-type-arg]
+    const rqw: Promise<number> = pool.query('select * from table;');
+    const rq2: Promise<ResultSet> = pool.query('Parameterized Queries',[1],
+     (err, result) => {
+       const _err: PG_ERROR|null = err;
+       // $FlowExpectedError[incompatible-type]
+       const _err_w: number = err;
+       const _result: ResultSet|void = result;
+       // $FlowExpectedError[incompatible-type]
+       const _result_w: number = result;
+     });
+     // $FlowExpectedError[incompatible-call]
+    const rq2_w: Promise<ResultSet> = pool.query('Parameterized Queries',1);
+
+    // 1.2 the pool also supports checking out a client for
+    // multiple operations, such as a transaction
+    const rc: Promise<PoolClient> = pool.connect( (err, client, done) => {
+      const _err: PG_ERROR|null = err;
+      // $FlowExpectedError[incompatible-type]
+      const _err_w: number = err;
+      const _client: PoolClient|null = client;
+      // $FlowExpectedError[incompatible-type]
+      const _client_w: number = client;
+      const _done: DoneCallback = done;
+      // $FlowExpectedError[incompatible-type]
+      const _done_w: number = done;
+    });
+    // $FlowExpectedError[incompatible-type]
+    const rc_w: number = pool.connect();
+
+    const rt: Promise<PoolClient> = pool.take( (err, client, done) => {
+      const _err: PG_ERROR|null = err;
+      // $FlowExpectedError[incompatible-type]
+      const _err_w: number = err;
+      const _client: PoolClient|null = client;
+      // $FlowExpectedError[incompatible-type]
+      const _client_w: number = client;
+      const _done: DoneCallback = done;
+      // $FlowExpectedError[incompatible-type]
+      const _done_w: number = done;
+    });
+    // $FlowExpectedError[incompatible-type]
+    const rt_w: number = pool.take();
+
+    const re: Promise<void> = pool.end( err => {
+      // $FlowExpectedError[incompatible-type]
+      const _err_w: string = err; // ?:mixed
+    });
+    // $FlowExpectedError[incompatible-type-arg]
+    const re_w: Promise<null> = pool.end();
+
+    // Note: There is a slight different between pool.query and client.query.
+    // client.query return a Query, pool.query return Promise<ResultSet>
+    // class Query extends Promise<ResultSet>
+    function test_PoolClient(client: PoolClient) {
+      const rr: void = client.release('any msg');
+      const rr1: void = client.release();
+      // $FlowExpectedError[incompatible-type]
+      const rr_w: null = client.release();
+      const rq: QueryType = client.query('select * from table;');
+      // $FlowExpectedError[incompatible-type-arg]
+      const rqw: Promise<number> = pool.query('select * from table;');
+      rq.on('row', (row, result) => {
+        const _row: Row = row;
+        const _result: ResultBuilder = result;
+        // $FlowExpectedError[incompatible-type]
+        const _row_w: number = row;
+        // $FlowExpectedError[incompatible-type]
+        const _result_w: number = result;
+      });
+      rq.on('end', (result) => {
+        const reselt: ResultBuilder = result;
+      });
+      rq.on('error', (err) => {
+        const _err: PG_ERROR = err;
+        // $FlowExpectedError[incompatible-type]
+        const _err_w: number = err;
+      });
+      // $FlowExpectedError[incompatible-call]
+      rq.on('wrong', ()=>{});
+
+
+      const rq2: Promise<ResultSet> = client.query('Parameterized Queries',[1],
+       (err, result) => {
+         const _err: PG_ERROR|null = err;
+         // $FlowExpectedError[incompatible-type]
+         const _err_w: number = err;
+         const _result: ResultSet|void = result;
+         // $FlowExpectedError[incompatible-type]
+         const _result_w: number = result;
+       });
+       // $FlowExpectedError[incompatible-call]
+      const rq2_w: Promise<ResultSet> = client.query('Parameterized Queries',1);
+
+      const rq3: QuerySubmittableConfig = client.query({
+          text: 'select * from table;',
+          submit: (connection: mixed): void => {
+            const _connection: mixed = connection;
+          },
+      });
+    }
+  }
+
+  // 2. instantiate a client directly.
+  function test_client() {
+    const client = new pg.Client();
+    client.connect((err, client) => {
+      const _err: PG_ERROR|null = err;
+      const _client: Client|void = client;
+      if (_client) {
+        const rq: QueryType = _client.query('select * from table;');
+        const rq2: Promise<ResultSet> = _client.query('Parameterized Queries',[1],
+         (err, result) => {
+           const _err: PG_ERROR|null = err;
+           // $FlowExpectedError[incompatible-type]
+           const _err_w: number = err;
+           const _result: ResultSet|void = result;
+           // $FlowExpectedError[incompatible-type]
+           const _result_w: number = result;
+         });
+        const rq3: QuerySubmittableConfig = _client.query({
+            text: 'select * from table;',
+            submit: (connection: mixed): void => {
+              const _connection: mixed = connection;
+            },
+        });
+         // $FlowExpectedError[incompatible-call]
+        const rq2_w: Promise<ResultSet> = _client.query('Parameterized Queries',1);
+
+        _client.on('drain', _ => {
+          const a: void = _;
+        });
+        // $FlowExpectedError[incompatible-call]
+        _client.on('drain',1);
+        _client.on('error', err => {
+          const _err: PG_ERROR = err;
+        });
+        // $FlowExpectedError[incompatible-call]
+        _client.on('error',1);
+        _client.on('notification', msg => {
+        });
+        // $FlowExpectedError[incompatible-call]
+        _client.on('notification',1);
+        _client.on('notice', msg => {
+        });
+        // $FlowExpectedError[incompatible-call]
+        _client.on('notice',1);
+        _client.on('end', _ => {
+          const a: void = _;
+        });
+        // $FlowExpectedError[incompatible-call]
+        _client.on('end',1);
+      }
+    });
+  }
+}
+
+// Simple example usage.
+const pool = new pg.Pool({
+  user: 'testuser',
+  password: 'testuser',
+  host: 'localhost',
+  database: 'testdb',
+  max: 10,
+  statement_timeout: false,
+  idleTimeoutMillis: 1000,
+  connectionTimeoutMillis: 1000
+});
+
+// use pool
+const promise_r = pool.query('select * from table;', ['11']);
+// $FlowExpectedError[incompatible-type]
+const p:boolean = promise_r; // Promise
+promise_r.then( result => {
+  // $FlowExpectedError[incompatible-type]
+  const v:boolean = result.command; // string
+  // $FlowExpectedError[incompatible-type]
+  const v2:boolean = result.oid; // string
+  // $FlowExpectedError[incompatible-type]
+  const v3:boolean = result.rowCount; // string
+  // $FlowExpectedError[incompatible-type]
+  const v4:boolean = result.rows; // Array
+  const rt:ResultSet = result; // the type of result
+})
+
+// directly use client
+const promise_client = pool.connect();
+promise_client.then( client => {
+  client.query('select * from table;')
+    .then( result => {
+      // $FlowExpectedError[incompatible-type]
+      const v:boolean = result; // result should be typed
+    });
+  client.release('error msg'); // accept error msg
+  client.release(); // or without arguments
+});
diff --git a/definitions/npm/plow-js_v2.1.x/flow_v0.104.x-/plow-js_v2.1.x.js b/definitions/npm/plow-js_v2.1.x/flow_v0.104.x-v0.200.x/plow-js_v2.1.x.js
similarity index 100%
rename from definitions/npm/plow-js_v2.1.x/flow_v0.104.x-/plow-js_v2.1.x.js
rename to definitions/npm/plow-js_v2.1.x/flow_v0.104.x-v0.200.x/plow-js_v2.1.x.js
diff --git a/definitions/npm/plow-js_v2.1.x/flow_v0.201.x-/plow-js_v2.1.x.js b/definitions/npm/plow-js_v2.1.x/flow_v0.201.x-/plow-js_v2.1.x.js
new file mode 100644
index 0000000000..3805fc3777
--- /dev/null
+++ b/definitions/npm/plow-js_v2.1.x/flow_v0.201.x-/plow-js_v2.1.x.js
@@ -0,0 +1,196 @@
+declare module "plow-js" {
+  declare type PathPartial = string | number;
+  declare type Path = PathPartial | Array<PathPartial>;
+  declare type Subject = Object;
+  declare type Mapper = PathPartial | ((value: any) => any);
+  declare type TransformShape = { [string]: Function, ... };
+  declare type BooleanStatementFn = (...args: any) => boolean;
+
+  /**
+   * Projections
+	 */
+  declare function $get(path: Path, subject: Subject): any;
+  declare function $get(path: Path): (subject: Subject) => any;
+
+  declare function $count(path: Path, subject: Subject): number;
+  declare function $count(path: Path): (subject: Subject) => number;
+
+  declare function $contains(value: any, path: Path, subject: Subject): boolean;
+  declare function $contains(
+    value: any,
+    path: Path
+  ): (subject: Subject) => boolean;
+  declare function $contains(
+    value: any
+  ): (path: Path) => (subject: Subject) => boolean;
+
+  declare function $head(path: Path, subject: Subject): any;
+  declare function $head(path: Path): (subject: Subject) => any;
+
+  declare function $tail(path: Path, subject: Subject): Array<any>;
+  declare function $tail(path: Path): (subject: Subject) => Array<any>;
+
+  declare function $last(path: Path, subject: Subject): any;
+  declare function $last(path: Path): (subject: Subject) => any;
+
+  declare function $map(mapper: Mapper, path: Path, subject: Subject): any;
+  declare function $map(mapper: Mapper, path: Path): (subject: Subject) => any;
+  declare function $map(
+    mapper: Mapper
+  ): (path: Path) => (subject: Subject) => any;
+
+  declare function $transform(shape: TransformShape, subject: Subject): Object;
+  declare function $transform(
+    shape: TransformShape
+  ): (subject: Subject) => Object;
+
+  declare function $resolve(pointer: Path, subject: Subject): any;
+  declare function $resolve(pointer: Path): (subject: Subject) => any;
+
+  // The all-in-one call is not yet supported due to https://github.com/facebook/flow/issues/2443
+  // declare function $and(...statementsAndSubject: Array<Function|Subject>): boolean;
+  declare function $and(
+    ...statements: Array<Function>
+  ): (subject: Subject) => boolean;
+
+  // The all-in-one call is not yet supported due to https://github.com/facebook/flow/issues/2443
+  // declare function $or(...statementsAndSubject: Array<Function|Subject>): boolean;
+  declare function $or(
+    ...statements: Array<Function>
+  ): (subject: Subject) => boolean;
+
+  declare function $not(
+    statement: BooleanStatementFn,
+    subject: Subject
+  ): boolean;
+  declare function $not(
+    statement: BooleanStatementFn
+  ): (subject: Subject) => boolean;
+
+  /**
+   * Migrations
+   */
+  declare function $set(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: Subject) => Subject;
+  declare function $set(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: Subject) => Subject;
+  declare function $set(path: Path, value: any, subject: Subject): Subject;
+
+  declare function $merge(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: Subject) => Subject;
+  declare function $merge(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: Subject) => Subject;
+  declare function $merge(path: Path, value: any, subject: Subject): Subject;
+
+  declare function $add<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: S) => $Shape<S>;
+  declare function $add<S>(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $add<S>(path: Path, value: any, subject: S): $Shape<S>;
+
+  declare function $drop<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $drop<S>(path: Path, subject: S): $Shape<S>;
+
+  declare function $override(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: Subject) => Subject;
+  declare function $override(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: Subject) => Subject;
+  declare function $override(path: Path, value: any, subject: Subject): Subject;
+
+  declare function $pop<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $pop<S>(path: Path, subject: S): $Shape<S>;
+
+  declare function $remove<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: S) => $Shape<S>;
+  declare function $remove<S>(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $remove<S>(path: Path, value: any, subject: S): $Shape<S>;
+
+  declare function $shift<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $shift<S>(path: Path, subject: S): $Shape<S>;
+
+  declare function $unshift<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: S) => $Shape<S>;
+  declare function $unshift<S>(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $unshift<S>(path: Path, value: any, subject: S): $Shape<S>;
+
+  declare function $toggle<S>(
+    path: Path,
+    ...rest: Array<void>
+  ): (value: any) => (subject: S) => $Shape<S>;
+  declare function $toggle<S>(
+    path: Path,
+    value: any,
+    ...rest: Array<void>
+  ): (subject: S) => $Shape<S>;
+  declare function $toggle<S>(path: Path, value: any, subject: S): $Shape<S>;
+
+  /**
+   * Connections
+   */
+  // The all-in-one call is not yet supported due to https://github.com/facebook/flow/issues/2443
+  // declare function $all(...statementsAndSubject: Array<Function|Subject>): Subject;
+  declare function $all(
+    ...statements: Array<Function>
+  ): (subject: Subject) => Subject;
+
+  declare function $summarize<R>(
+    operations: Array<Function>,
+    ...rest: Array<void>
+  ): (finisher: (...args: Array<any>) => R) => (subject: Subject) => R;
+  declare function $summarize<R>(
+    operations: Array<Function>,
+    finisher: (...args: Array<any>) => R,
+    ...rest: Array<void>
+  ): (subject: Subject) => R;
+  declare function $summarize<R>(
+    operations: Array<Function>,
+    finisher: (...args: Array<any>) => R,
+    subject: Subject
+  ): R;
+
+  declare function $traverse(actor: Function): (subject: Subject) => Subject;
+  declare function $traverse(actor: Function, subject: Subject): Subject;
+
+  declare function $log(pathOrSubject: Path | Subject, subject?: Subject): any;
+}
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/puppeteer_v1.20.x.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/puppeteer_v1.20.x.js
similarity index 100%
rename from definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/puppeteer_v1.20.x.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/puppeteer_v1.20.x.js
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_connect.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_connect.js
similarity index 100%
rename from definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_connect.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_connect.js
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_defaultArgs.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_defaultArgs.js
similarity index 100%
rename from definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_defaultArgs.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_defaultArgs.js
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_executablePath.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_executablePath.js
similarity index 100%
rename from definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_executablePath.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_executablePath.js
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_launch.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_launch.js
similarity index 100%
rename from definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-/test_puppeteer_v1.20.x_launch.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.104.x-v0.200.x/test_puppeteer_v1.20.x_launch.js
diff --git a/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/puppeteer_v1.20.x.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/puppeteer_v1.20.x.js
new file mode 100644
index 0000000000..0c4c6487ff
--- /dev/null
+++ b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/puppeteer_v1.20.x.js
@@ -0,0 +1,1372 @@
+// @flow
+
+/**
+ * Based on typescript definitions found at the url below
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/puppeteer
+ */
+
+ declare module 'puppeteer' {
+  import type { ChildProcess } from 'child_process';
+
+  declare class OverridableEventEmitter extends events$EventEmitter {
+    /* eslint-disable flowtype/no-weak-types */
+    +on: Function;
+    +once: Function;
+    /* eslint-enable flowtype/no-weak-types */
+  }
+
+  /** Keyboard provides an api for managing a virtual keyboard. */
+  declare export type Keyboard = {
+   /**
+    * Dispatches a keydown event.
+    * @param key Name of key to press, such as ArrowLeft.
+    * @param options Specifies a input text event.
+    */
+   down(key: string, options?: { text?: string, ... }): Promise<void>,
+   /** Shortcut for `keyboard.down` and `keyboard.up`. */
+   press(key: string, options?: {
+    delay?: number,
+    text?: string,
+    ...
+   }): Promise<void>,
+   /** Dispatches a `keypress` and `input` event. This does not send a `keydown` or keyup `event`. */
+   sendCharacter(char: string): Promise<void>,
+   /**
+    * Sends a keydown, keypress/input, and keyup event for each character in the text.
+    * @param text A text to type into a focused element.
+    * @param options Specifies the typing options.
+    */
+   type(text: string, options?: { delay?: number, ... }): Promise<void>,
+   /**
+    * Dispatches a keyup event.
+    * @param key Name of key to release, such as ArrowLeft.
+    */
+   up(key: string): Promise<void>,
+   ...
+  };
+
+  declare export type MousePressOptions = {
+   /**
+    * left, right, or middle.
+    * @default left
+    */
+   button?: MouseButtons,
+   /**
+    * The number of clicks.
+    * @default 1
+    */
+   clickCount?: number,
+   ...
+  };
+
+  declare export type Mouse = {
+   /**
+    * Shortcut for `mouse.move`, `mouse.down` and `mouse.up`.
+    * @param x The x position.
+    * @param y The y position.
+    * @param options The click options.
+    */
+   click(x: number, y: number, options?: ClickOptions): Promise<void>,
+   /**
+    * Dispatches a `mousedown` event.
+    * @param options The mouse press options.
+    */
+   down(options?: MousePressOptions): Promise<void>,
+   /**
+    * Dispatches a `mousemove` event.
+    * @param x The x position.
+    * @param y The y position.
+    * @param options The mouse move options.
+    */
+   move(x: number, y: number, options?: { steps: number, ... }): Promise<void>,
+   /**
+    * Dispatches a `mouseup` event.
+    * @param options The mouse press options.
+    */
+   up(options?: MousePressOptions): Promise<void>,
+   ...
+  };
+
+  declare export type Touchscreen = { /**
+   * Dispatches a touchstart and touchend event.
+   * @param x The x position.
+   * @param y The y position.
+   */
+  tap(x: number, y: number): Promise<void>, ... };
+
+  /**
+   * You can use `tracing.start` and `tracing.stop` to create a trace file which can be opened in Chrome DevTools or timeline viewer.
+   */
+  declare export type Tracing = {
+   start(options: TracingStartOptions): Promise<void>,
+   stop(): Promise<void>,
+   ...
+  };
+
+  declare export type TracingStartOptions = {
+   categories?: Array<string>,
+   path: string,
+   screenshots?: boolean,
+   ...
+  };
+
+  /** Dialog objects are dispatched by page via the 'dialog' event. */
+  declare export type Dialog = {
+   /**
+    * Accepts the dialog.
+    * @param promptText A text to enter in prompt. Does not cause any effects if the dialog's type is not prompt.
+    */
+   accept(promptText?: string): Promise<void>,
+   /** If dialog is prompt, returns default prompt value. Otherwise, returns empty string. */
+   defaultValue(): string,
+   /** Dismiss the dialog */
+   dismiss(): Promise<void>,
+   /** Returns the message displayed in the dialog. */
+   message(): string,
+   /** The dialog type. Dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`. */
+   type(): 'alert' | 'beforeunload' | 'confirm' | 'prompt',
+   ...
+  };
+
+  /** ConsoleMessage objects are dispatched by page via the 'console' event. */
+  declare export type ConsoleMessage = {
+   /** The message arguments. */
+   args(): Array<JSHandle>,
+   /** The message text. */
+   text(): string,
+   type():
+     | 'log'
+     | 'debug'
+     | 'info'
+     | 'error'
+     | 'warning'
+     | 'dir'
+     | 'dirxml'
+     | 'table'
+     | 'trace'
+     | 'clear'
+     | 'startGroup'
+     | 'startGroupCollapsed'
+     | 'endGroup'
+     | 'assert'
+     | 'profile'
+     | 'profileEnd'
+     | 'count'
+     | 'timeEnd',
+   ...
+  };
+
+  declare export type PageEvents =
+    | 'console'
+    | 'dialog'
+    | 'error'
+    | 'frameattached'
+    | 'framedetached'
+    | 'framenavigated'
+    | 'load'
+    | 'pageerror'
+    | 'request'
+    | 'requestfailed'
+    | 'requestfinished'
+    | 'response';
+
+  declare export type BrowserEvents =
+    | 'disconnected'
+    | 'targetchanged'
+    | 'targetcreated'
+    | 'targetdestroyed';
+
+  declare export type AuthOptions = {
+   password: string,
+   username: string,
+   ...
+  };
+
+  declare export type MouseButtons = 'left' | 'right' | 'middle';
+
+  declare export type ClickOptions = {
+   /** defaults to left */
+   button?: MouseButtons,
+   /** defaults to 1 */
+   clickCount?: number,
+   /**
+    * Time to wait between mousedown and mouseup in milliseconds.
+    * Defaults to 0.
+    */
+   delay?: number,
+   ...
+  };
+
+  /** Represents a browser cookie. */
+  declare export type Cookie = {
+   /** The cookie domain. */
+   domain: string,
+   /** The cookie Unix expiration time in seconds. */
+   expires: number,
+   /** The cookie http only flag. */
+   httpOnly: boolean,
+   /** The cookie name. */
+   name: string,
+   /** The cookie path. */
+   path: string,
+   /** The cookie same site definition. */
+   sameSite: 'Strict' | 'Lax',
+   /** The cookie secure flag. */
+   secure: boolean,
+   /** The cookie value. */
+   value: string,
+   ...
+  };
+
+  declare export type DeleteCookie = {
+   domain?: string,
+   /** The cookie name. */
+   name: string,
+   path?: string,
+   secure?: boolean,
+   url?: string,
+   ...
+  };
+
+  declare export type SetCookie = {
+   /** The cookie domain. */
+   domain?: string,
+   /** The cookie Unix expiration time in seconds. */
+   expires?: number,
+   /** The cookie http only flag. */
+   httpOnly?: boolean,
+   /** The cookie name. */
+   name: string,
+   /** The cookie path. */
+   path?: string,
+   /** The cookie same site definition. */
+   sameSite?: 'Strict' | 'Lax',
+   /** The cookie secure flag. */
+   secure?: boolean,
+   /** The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie. */
+   url?: string,
+   /** The cookie value. */
+   value: string,
+   ...
+  };
+
+  declare export type Viewport = {
+   /**
+    * Specify device scale factor (can be thought of as dpr).
+    * @default 1
+    */
+   deviceScaleFactor?: number,
+   /**
+    * Specifies if viewport supports touch events.
+    * @default false
+    */
+   hasTouch?: boolean,
+   /** The page height in pixels. */
+   height: number,
+   /**
+    * Specifies if viewport is in landscape mode.
+    * @default false
+    */
+   isLandscape?: boolean,
+   /**
+    * Whether the `meta viewport` tag is taken into account.
+    * @default false
+    */
+   isMobile?: boolean,
+   /** The page width in pixels. */
+   width: number,
+   ...
+  };
+
+  /** Page emulation options. */
+  declare export type EmulateOptions = {
+   /** The emulated user-agent. */
+   userAgent?: string,
+   /** The viewport emulation options. */
+   viewport?: Viewport,
+   ...
+  };
+
+  declare export type EvaluateFn = string | ((...args: Array<mixed>) => mixed);
+
+  declare export type LoadEvent = 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+
+  /** The navigation options. */
+  declare export type NavigationOptions = {
+   /**
+    * Maximum navigation time in milliseconds, pass 0 to disable timeout.
+    * @default 30000
+    */
+   timeout?: number,
+   /**
+    * When to consider navigation succeeded.
+    * @default load Navigation is consider when the `load` event is fired.
+    */
+   waitUntil?: LoadEvent | Array<LoadEvent>,
+   ...
+  };
+
+  declare export type PDFFormat =
+    | 'Letter'
+    | 'Legal'
+    | 'Tabload'
+    | 'Ledger'
+    | 'A0'
+    | 'A1'
+    | 'A2'
+    | 'A3'
+    | 'A4'
+    | 'A5';
+
+  declare export type PDFOptions = {
+   /**
+    * Display header and footer.
+    * @default false
+    */
+   displayHeaderFooter?: boolean,
+   /**
+    * HTML template for the print footer. Should be valid HTML markup with following classes used to inject printing values into them:
+    * - `date` formatted print date
+    * - `title` document title
+    * - `url` document location
+    * - `pageNumber` current page number
+    * - `totalPages` total pages in the document
+    */
+   footerTemplate?: string,
+   /** Paper format. If set, takes priority over width or height options. Defaults to 'Letter'. */
+   format?: PDFFormat,
+   /**
+    * HTML template for the print header. Should be valid HTML markup with following classes used to inject printing values into them:
+    * - `date` formatted print date
+    * - `title` document title
+    * - `url` document location
+    * - `pageNumber` current page number
+    * - `totalPages` total pages in the document
+    */
+   headerTemplate?: string,
+   /** Paper height, accepts values labeled with units. */
+   height?: string,
+   /**
+    * Paper orientation.
+    * @default false
+    */
+   landscape?: boolean,
+   /** Paper margins, defaults to none.  */
+   margin?: {
+    /** Bottom margin, accepts values labeled with units. */
+    bottom?: string,
+    /** Left margin, accepts values labeled with units. */
+    left?: string,
+    /** Right margin, accepts values labeled with units. */
+    right?: string,
+    /** Top margin, accepts values labeled with units. */
+    top?: string,
+    ...
+   },
+   /**
+    * Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty
+    * string, which means print all pages.
+    */
+   pageRanges?: string,
+   /**
+    * The file path to save the PDF to.
+    * If `path` is a relative path, then it is resolved relative to current working directory.
+    * If no path is provided, the PDF won't be saved to the disk.
+    */
+   path?: string,
+   /**
+    * Print background graphics.
+    * @default false
+    */
+   printBackground?: boolean,
+   /**
+    * Scale of the webpage rendering.
+    * @default 1
+    */
+   scale?: number,
+   /** Paper width, accepts values labeled with units. */
+   width?: string,
+   ...
+  };
+
+  /** Defines the screenshot options. */
+  declare export type ScreenshotOptions = {
+   /**
+    * An object which specifies clipping region of the page.
+    */
+   clip?: BoundingBox,
+   /**
+    * When true, takes a screenshot of the full scrollable page.
+    * @default false
+    */
+   fullPage?: boolean,
+   /**
+    * Hides default white background and allows capturing screenshots with transparency.
+    * @default false
+    */
+   omitBackground?: boolean,
+   /**
+    * The file path to save the image to. The screenshot type will be inferred from file extension.
+    * If `path` is a relative path, then it is resolved relative to current working directory.
+    * If no path is provided, the image won't be saved to the disk.
+    */
+   path?: string,
+   /** The quality of the image, between 0-100. Not applicable to png images. */
+   quality?: number,
+   /**
+    * The screenshot type.
+    * @default png
+    */
+   type?: 'jpeg' | 'png',
+   ...
+  };
+
+  /** Options for `addStyleTag` */
+  declare export type StyleTagOptions = {
+   /** Raw CSS content to be injected into frame. */
+   content?: string,
+   /** Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
+   path?: string,
+   /** Url of the <link> tag. */
+   url?: string,
+   ...
+  };
+  /** Options for `addScriptTag` */
+  declare export type ScriptTagOptions = {
+   /** Raw JavaScript content to be injected into frame. */
+   content?: string,
+   /** Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
+   path?: string,
+   /** Script type. Use 'module' in order to load a Javascript ES6 module. */
+   type?: string,
+   /** Url of a script to be added. */
+   url?: string,
+   ...
+  };
+
+  declare export type PageFnOptions = {
+   polling?: 'raf' | 'mutation' | number,
+   timeout?: number,
+   ...
+  };
+
+  declare export type BoundingBox = {
+   /** The height. */
+   height: number,
+   /** The width. */
+   width: number,
+   /** The x-coordinate of top-left corner. */
+   x: number,
+   /** The y-coordinate of top-left corner. */
+   y: number,
+   ...
+  };
+
+  /**
+   * Represents an in-page DOM element. ElementHandles can be created with the page.$ method.
+   */
+  declare export type ElementHandle = JSHandle & {
+   /**
+    * The method runs element.querySelector within the page. If no element matches the selector, the return value resolve to null.
+    * @param selector A selector to query element for
+    * @since 0.13.0
+    */
+   $(selector: string): Promise<ElementHandle | null>,
+   /**
+    * The method runs element.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
+    * @param selector A selector to query element for
+    * @since 0.13.0
+    */
+   $$(selector: string): Promise<Array<ElementHandle>>,
+   /**
+    * @param selector XPath expression to evaluate.
+    */
+   $x(expression: string): Promise<Array<ElementHandle>>,
+   /**
+    * This method returns the value resolve to the bounding box of the element (relative to the main frame), or null if the element is not visible.
+    */
+   boundingBox(): Promise<BoundingBox | null>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.mouse to click in the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    * @param options Specifies the options.
+    * @since 0.9.0
+    */
+   click(options?: ClickOptions): Promise<void>,
+   /**
+    * @returns Resolves to the content frame for element handles referencing iframe nodes, or null otherwise.
+    * @since 1.2.0
+    */
+   contentFrame(): Promise<?Frame>,
+   /**
+    * Calls focus on the element.
+    */
+   focus(): Promise<void>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.mouse to hover over the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    */
+   hover(): Promise<void>,
+   /**
+    * Focuses the element, and then uses keyboard.down and keyboard.up.
+    * @param key Name of key to press, such as ArrowLeft. See USKeyboardLayout for a list of all key names.
+    * @param options The text and delay options.
+    */
+   press(key: string, options?: {
+    delay?: number,
+    text?: string,
+    ...
+   }): Promise<void>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.screenshot to take a screenshot of the element.
+    * If the element is detached from DOM, the method throws an error.
+    * @param options Same options as in page.screenshot.
+    */
+   screenshot(options?: ScreenshotOptions): Promise<Buffer>,
+   /**
+    * This method scrolls element into view if needed, and then uses touchscreen.tap to tap in the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    */
+   tap(): Promise<void>,
+   toString(): string,
+   /**
+    * Focuses the element, and then sends a keydown, keypress/input, and keyup event for each character in the text.
+    * @param text A text to type into a focused element.
+    * @param options The typing options.
+    */
+   type(text: string, options?: { delay: number, ... }): Promise<void>,
+   /**
+    * This method expects elementHandle to point to an input element.
+    * @param filePaths Sets the value of the file input these paths. If some of the filePaths are relative paths, then they are resolved relative to current working directory.
+    */
+   uploadFile(...filePaths: Array<string>): Promise<void>,
+   ...
+  };
+
+  /** The class represents a context for JavaScript execution. */
+  declare export type ExecutionContext = {
+   evaluate(fn: EvaluateFn, ...args: Array<mixed>): Promise<mixed>,
+   evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>,
+   queryObjects(prototypeHandle: JSHandle): JSHandle,
+   ...
+  };
+
+  /** JSHandle represents an in-page JavaScript object. */
+  declare export type JSHandle = {
+   /**
+    * Returns a ElementHandle
+    */
+   asElement(): ElementHandle | null,
+   /**
+    * Stops referencing the element handle.
+    */
+   dispose(): Promise<void>,
+   /**
+    * Gets the execution context.
+    */
+   executionContext(): ExecutionContext,
+   /**
+    * Returns a map with property names as keys and JSHandle instances for the property values.
+    */
+   getProperties(): Promise<Map<string, JSHandle>>,
+   /**
+    * Fetches a single property from the objectHandle.
+    * @param propertyName The property to get.
+    */
+   getProperty(propertyName: string): Promise<JSHandle>,
+   /**
+    * Returns a JSON representation of the object.
+    * The JSON is generated by running JSON.stringify on the object in page and consequent JSON.parse in puppeteer.
+    * @throws The method will throw if the referenced object is not stringifiable.
+    */
+   jsonValue(): Promise<mixed>,
+   ...
+  };
+
+  declare export type Metrics = {
+   /** Number of documents in the page. */
+   Documents: number,
+   /** Number of frames in the page. */
+   Frames: number,
+   /** Number of events in the page. */
+   JSEventListeners: number,
+   /** Total JavaScript heap size. */
+   JSHeapTotalSize: number,
+   /** Used JavaScript heap size. */
+   JSHeapUsedSize: number,
+   /** Total number of full or partial page layout. */
+   LayoutCount: number,
+   /** Combined durations of all page layouts. */
+   LayoutDuration: number,
+   /** Number of DOM nodes in the page. */
+   Nodes: number,
+   /** Total number of page style recalculations. */
+   RecalcStyleCount: number,
+   /** Combined duration of all page style recalculations. */
+   RecalcStyleDuration: number,
+   /** Combined duration of JavaScript execution. */
+   ScriptDuration: number,
+   /** Combined duration of all tasks performed by the browser. */
+   TaskDuration: number,
+   /** The timestamp when the metrics sample was taken. */
+   Timestamp: number,
+   ...
+  };
+
+  declare export type Headers = { [key: string]: string, ... };
+  declare export type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE' | 'OPTIONS';
+
+  declare export type ResourceType =
+    | 'document'
+    | 'stylesheet'
+    | 'image'
+    | 'media'
+    | 'font'
+    | 'script'
+    | 'texttrack'
+    | 'xhr'
+    | 'fetch'
+    | 'eventsource'
+    | 'websocket'
+    | 'manifest'
+    | 'other';
+
+  declare export type Overrides = {
+   headers?: Headers,
+   method?: HttpMethod,
+   postData?: string,
+   url?: string,
+   ...
+  };
+
+  /** Represents a page request. */
+  declare export type Request = {
+   /**
+    * Aborts request.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    */
+   abort(): Promise<void>,
+   /**
+    * Continues request with optional request overrides.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    */
+   continue(overrides?: Overrides): Promise<void>,
+   /**
+    * @returns The `Frame` object that initiated the request, or `null` if navigating to error pages
+    */
+   frame(): Promise<?Frame>,
+   /**
+    * An object with HTTP headers associated with the request.
+    * All header names are lower-case.
+    */
+   headers(): Headers,
+   /** Returns the request's method (GET, POST, etc.) */
+
+   method(): HttpMethod,
+   /** Contains the request's post body, if any. */
+   postData(): ?string,
+   /**
+    * A `redirectChain` is a chain of requests initiated to fetch a resource.
+    *
+    * - If there are no redirects and the request was successful, the chain will be empty.
+    * - If a server responds with at least a single redirect, then the chain will contain all the requests that were redirected.
+    *
+    * `redirectChain` is shared between all the requests of the same chain.
+    *
+    * @since 1.2.0
+    */
+   redirectChain(): Array<Request>,
+   /** Contains the request's resource type as it was perceived by the rendering engine.  */
+   resourceType(): ResourceType,
+   /**
+    * Fulfills request with given response.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    * @param response The response options that will fulfill this request.
+    */
+   respond(response: RespondOptions): Promise<void>,
+   /** A matching `Response` object, or `null` if the response has not been received yet. */
+   response(): ?Response,
+   /** Contains the URL of the request. */
+   url(): string,
+   ...
+  };
+
+  /** Options for `Request.respond` method */
+  declare export type RespondOptions = {
+   /** Specifies the response body. */
+   body?: Buffer | string,
+   /** Specifies the Content-Type response header. */
+   contentType?: string,
+   /** Specifies the response headers. */
+   headers?: Headers,
+   /**
+    * Specifies the response status code.
+    * @default 200
+    */
+   status?: number,
+   ...
+  };
+
+  /** Response class represents responses which are received by page. */
+  declare export type Response = {
+   /** Promise which resolves to a buffer with response body. */
+   buffer(): Promise<Buffer>,
+   /** True if the response was served from either the browser's disk cache or memory cache. */
+   fromCache(): boolean,
+   /** True if the response was served by a service worker. */
+   fromServiceWorker(): boolean,
+   /** An object with HTTP headers associated with the response. All header names are lower-case. */
+   headers(): Headers,
+   /**
+    * Promise which resolves to a JSON representation of response body.
+    * @throws This method will throw if the response body is not parsable via `JSON.parse`.
+    */
+   json(): Promise<mixed>,
+   /** Contains a boolean stating whether the response was successful (status in the range 200-299) or not. */
+   ok(): boolean,
+   /** A matching Request object. */
+   request(): Request,
+   /** Contains the status code of the response (e.g., 200 for a success). */
+   status(): number,
+   /** Promise which resolves to a text representation of response body. */
+   text(): Promise<string>,
+   /** Contains the URL of the response. */
+   url(): string,
+   ...
+  };
+
+  declare class FrameBase {
+    /**
+     * The method runs document.querySelector within the page.
+     * If no element matches the selector, the return value resolve to null.
+     */
+    $: (selector: string) => Promise<?ElementHandle>;
+
+    /**
+     * The method runs document.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
+     */
+    $$: (selector: string) => Promise<Array<ElementHandle>>;
+
+    /**
+     * This method runs document.querySelectorAll within the page and passes it as the first argument to `fn`.
+     * If `fn` returns a Promise, then $$eval would wait for the promise to resolve and return its value.
+     * @param selector A selector to query frame for
+     * @param fn Function to be evaluated in browser context
+     * @param args Arguments to pass to pageFunction
+     * @returns Promise which resolves to the return value of pageFunction
+     */
+    $$eval: (
+      selector: string,
+      pageFunction: (
+        elements: NodeList<Element>,
+        ...args: Array<mixed>
+      ) => mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    /**
+     * This method runs document.querySelector within the page and passes it as the first argument to `fn`.
+     * If there's no element matching selector, the method throws an error.
+     * If `fn` returns a Promise, then $eval would wait for the promise to resolve and return its value.
+     */
+    $eval: (
+      selector: string,
+      pageFunction: (element: Element, ...args: Array<mixed>) => mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    /**
+     * @param expression XPath expression to evaluate.
+     */
+    $x: (expression: string) => Promise<Array<ElementHandle>>;
+
+    /** Adds a `<script>` tag into the page with the desired url or content. */
+    addScriptTag: (options: ScriptTagOptions) => Promise<void>;
+
+    /** Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content. */
+    addStyleTag: (options: StyleTagOptions) => Promise<void>;
+
+    /** Gets the full HTML contents of the page, including the doctype. */
+    content: () => Promise<string>;
+
+    /**
+     * Evaluates a function in the browser context.
+     * If the function, passed to the frame.evaluate, returns a Promise, then frame.evaluate would wait for the promise to resolve and return its value.
+     * If the function passed into frame.evaluate returns a non-Serializable value, then frame.evaluate resolves to undefined.
+     * @param fn Function to be evaluated in browser context
+     * @param args Arguments to pass to `fn`
+     */
+    evaluate: (fn: EvaluateFn, ...args: Array<mixed>) => Promise<mixed>;
+
+    /**
+     * Sets the page content.
+     * @param html HTML markup to assign to the page.
+     */
+    setContent: (html: string) => Promise<void>;
+
+    /** Returns page's title. */
+    +title: () => Promise<string>;
+
+    /** Returns frame's url. */
+    +url: () => string;
+
+    waitFor: (
+      // fn can be an abritary function
+      // eslint-disable-next-line flowtype/no-weak-types
+      selectorOrFunctionOrTimeout: string | number | Function,
+      options?: mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    waitForFunction: (
+      // fn can be an abritary function
+      // eslint-disable-next-line flowtype/no-weak-types
+      fn: string | Function,
+      options?: PageFnOptions,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    waitForSelector: (
+      selector: string,
+      options?: {
+       hidden?: boolean,
+       timeout?: number,
+       visible?: boolean,
+       ...
+      }
+    ) => Promise<ElementHandle>;
+  }
+
+  declare export type Frame = FrameBase & {
+   childFrames(): Array<Frame>,
+   /** Execution context associated with this frame. */
+   executionContext(): ExecutionContext,
+   /** Returns `true` if the frame has been detached, or `false` otherwise. */
+   isDetached(): boolean,
+   /** Returns frame's name attribute as specified in the tag. */
+   name(): string,
+   /** Returns parent frame, if any. Detached frames and main frames return null. */
+   parentFrame(): ?Frame,
+   ...
+  };
+
+  declare export type PageEventObj = {
+   /**
+    * Emitted when JavaScript within the page calls one of console API methods, e.g. console.log or console.dir.
+    * Also emitted if the page throws an error or a warning.
+    */
+   console: ConsoleMessage,
+   /**
+    * Emitted when a JavaScript dialog appears, such as alert, prompt, confirm or beforeunload.
+    * Puppeteer can respond to the dialog via Dialog's accept or dismiss methods.
+    */
+   dialog: Dialog,
+   /** Emitted when the page crashes. */
+   error: Error,
+   /** Emitted when a frame is attached. */
+   frameattached: Frame,
+   /** Emitted when a frame is detached. */
+   framedetached: Frame,
+   /** Emitted when a frame is navigated to a new url. */
+   framenavigated: Frame,
+   /** Emitted when the JavaScript load event is dispatched. */
+   load: void,
+   /**
+    * Emitted when the JavaScript code makes a call to `console.timeStamp`.
+    * For the list of metrics see `page.metrics`.
+    */
+   metrics: {
+    metrics: mixed,
+    title: string,
+    ...
+   },
+   /** Emitted when an uncaught exception happens within the page. */
+   pageerror: string,
+   /**
+    * Emitted when a page issues a request. The request object is read-only.
+    * In order to intercept and mutate requests, see page.setRequestInterceptionEnabled.
+    */
+   request: Request,
+   /** Emitted when a request fails, for example by timing out. */
+   requestfailed: Request,
+   /** Emitted when a request finishes successfully. */
+   requestfinished: Request,
+   /** Emitted when a response is received. */
+   response: Response,
+   ...
+  };
+
+  /** Page provides methods to interact with a single tab in Chromium. One Browser instance might have multiple Page instances. */
+  declare export interface Page extends OverridableEventEmitter, FrameBase {
+    /**
+     * Provide credentials for http authentication.
+     * To disable authentication, pass `null`.
+     */
+    authenticate(credentials: AuthOptions | null): Promise<void>;
+
+    /** Brings page to front (activates tab). */
+    bringToFront(): Promise<void>;
+
+    /**
+     * This method fetches an element with selector, scrolls it into view if needed, and
+     * then uses `page.mouse` to click in the center of the element. If there's no element
+     * matching selector, the method throws an error.
+     * @param selector A selector to search for element to click. If there are multiple elements satisfying the selector, the first will be clicked.
+     * @param options Specifies the click options.
+     */
+    click(selector: string, options?: ClickOptions): Promise<void>;
+
+    /** Closes the current page. */
+    close(): Promise<void>;
+
+    /**
+     * Gets the cookies.
+     * If no URLs are specified, this method returns cookies for the current page URL.
+     * If URLs are specified, only cookies for those URLs are returned.
+     */
+    cookies(...urls: Array<string>): Promise<Array<Cookie>>;
+
+    coverage: Coverage;
+
+    /**
+     * Deletes the specified cookies.
+     */
+    deleteCookie(...cookies: Array<DeleteCookie>): Promise<void>;
+
+    /** Emulates given device metrics and user agent. This method is a shortcut for `setUserAgent` and `setViewport`.  */
+    emulate(options: $Shape<EmulateOptions>): Promise<void>;
+
+    /** Emulates the media. */
+    emulateMedia(mediaType: 'screen' | 'print' | null): Promise<void>;
+
+    /**
+     * Evaluates a function in the page context.
+     * If the function, passed to the page.evaluateHandle, returns a Promise, then page.evaluateHandle
+     * would wait for the promise to resolve and return its value.
+     * @param fn The function to be evaluated in the page context.
+     * @param args The arguments to pass to the `fn`.
+     * @returns A promise which resolves to return value of `fn`.
+     */
+    evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>;
+
+    /**
+     * Adds a function which would be invoked in one of the following scenarios: whenever the page is navigated; whenever the child frame is attached or navigated.
+     * The function is invoked after the document was created but before any of its scripts were run. This is useful to amend JavaScript environment, e.g. to seed Math.random.
+     * @param fn The function to be evaluated in browser context.
+     * @param args The arguments to pass to the `fn`.
+     */
+    evaluateOnNewDocument(fn: EvaluateFn, ...args: Array<mixed>): Promise<void>;
+
+    /**
+     * The method adds a function called name on the page's `window` object.
+     * When called, the function executes `puppeteerFunction` in node.js and returns a
+     * Promise which resolves to the return value of `puppeteerFunction`.
+     * @param name The name of the function on the window object.
+     * @param fn Callback function which will be called in Puppeteer's context.
+     */
+    exposeFunction(
+      name: string,
+      puppeteerFunction: (...args: Array<mixed>) => mixed
+    ): Promise<void>;
+
+    /** This method fetches an element with selector and focuses it. */
+    focus(selector: string): Promise<void>;
+
+    /** An array of all frames attached to the page. */
+    frames(): Array<Frame>;
+
+    /**
+     * Navigate to the previous page in history.
+     * @param options The navigation parameters.
+     */
+    goBack(options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * Navigate to the next page in history.
+     * @param options The navigation parameters.
+     */
+    goForward(options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * Navigates to a URL.
+     * @param url URL to navigate page to. The url should include scheme, e.g. `https://`
+     * @param options The navigation parameters.
+     */
+    goto(url: string, options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * This method fetches an element with `selector`, scrolls it into view if needed,
+     * and then uses page.mouse to hover over the center of the element. If there's no
+     * element matching `selector`, the method throws an error.
+     * @param selector A selector to search for element to hover. If there are multiple elements satisfying the selector, the first will be hovered.
+     */
+    hover(selector: string): Promise<void>;
+
+    /** Returns the virtual keyboard. */
+    keyboard: Keyboard;
+
+    /** Page is guaranteed to have a main frame which persists during navigation's. */
+    mainFrame(): Frame;
+
+    /** Gets the page metrics. */
+    metrics(): Promise<Metrics>;
+
+    /** Gets the virtual mouse. */
+    mouse: Mouse;
+
+    /**
+     * Adds the listener function to the end of the listeners array for the event named `eventName`.
+     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
+     * `eventName` and listener will result in the listener being added, and called, multiple times.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    on<K: PageEvents>(
+      eventName: K,
+      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
+    ): Page;
+
+    /**
+     * Adds a one time listener function for the event named `eventName`.
+     * The next time `eventName` is triggered, this listener is removed and then invoked.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    once<K: PageEvents>(
+      eventName: K,
+      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
+    ): Page;
+
+    /**
+     * Generates a PDF of the page with `print` css media.
+     * To generate a pdf with `screen` media, call `page.emulateMedia('screen')` before calling `page.pdf()`:
+     * @param options The PDF parameters.
+     */
+    pdf(options?: $Shape<PDFOptions>): Promise<Buffer>;
+
+    /**
+     * The method iterates JavaScript heap and finds all the objects with the given prototype.
+     * @param prototypeHandle A handle to the object prototype.
+     */
+    queryObjects(prototypeHandle: JSHandle): Promise<JSHandle>;
+
+    /**
+     * Reloads the current page.
+     * @param options The navigation parameters.
+     */
+    reload(options?: NavigationOptions): Promise<Response>;
+
+    /**
+     * Captures a screenshot of the page.
+     * @param options The screenshot options.
+     */
+    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
+
+    /**
+     * Triggers a `change` and `input` event once all the provided options have been selected.
+     * If there's no `<select>` element matching selector, the method throws an error.
+     * @param selector A selector to query page for.
+     * @param values Values of options to select. If the `<select>` has the `multiple` attribute,
+     * all values are considered, otherwise only the first one is taken into account.
+     */
+    select(selector: string, ...values: Array<string>): Promise<Array<string>>;
+
+    /**
+     * Determines whether cache is enabled on the page.
+     * @param enabled Whether or not to enable cache on the page.
+     */
+    setCacheEnabled(enabled: boolean): Promise<void>;
+
+    /**
+     * Sets the cookies on the page.
+     * @param cookies The cookies to set.
+     */
+    setCookie(...cookies: Array<SetCookie>): Promise<void>;
+
+    /**
+     * This setting will change the default maximum navigation time of 30 seconds for the following methods:
+     * - `page.goto`
+     * - `page.goBack`
+     * - `page.goForward`
+     * - `page.reload`
+     * - `page.waitForNavigation`
+     */
+    setDefaultNavigationTimeout(timeout: number): void;
+
+    /**
+     * The extra HTTP headers will be sent with every request the page initiates.
+     * @param headers An object containing additional http headers to be sent with every request. All header values must be strings.
+     */
+    setExtraHTTPHeaders(headers: Headers): Promise<void>;
+
+    /**
+     * Determines whether JavaScript is enabled on the page.
+     * @param enable Whether or not to enable JavaScript on the page.
+     */
+    setJavaScriptEnabled(enabled: boolean): Promise<void>;
+
+    /**
+     * Determines whether the offline mode is enabled.
+     * @param enabled When `true`, enables the offline mode for the page.
+     */
+    setOfflineMode(enabled: boolean): Promise<void>;
+
+    /**
+     * Determines whether the request interception is enabled.
+     * @param enabled When `true` the methods `request.abort`, `request.continue` and `request.respond` must be used.
+     */
+    setRequestInterception(enabled: boolean): Promise<void>;
+
+    /**
+     * Specifies the User-Agent used in this page.
+     * @param userAgent The user-agent to be used in the page.
+     */
+    setUserAgent(userAgent: string): Promise<void>;
+
+    /**
+     * Sets the viewport of the page.
+     * @param viewport The viewport parameters.
+     */
+    setViewport(viewport: Viewport): Promise<void>;
+
+    /**
+     * This method fetches an element with `selector`, scrolls it into view if needed,
+     * and then uses page.touchscreen to tap in the center of the element.
+     * @param selector A `selector` to search for element to tap. If there are multiple elements
+     * satisfying the selector, the first will be tapped.
+     */
+    tap(selector: string): Promise<void>;
+
+    /** @returns The target this page was created from */
+    target(): Target;
+
+    /** Returns the page's title. */
+    +title: () => Promise<string>;
+
+    /** Returns the virtual touchscreen object. */
+    touchscreen: Touchscreen;
+
+    /** Returns the tracing object. */
+    tracing: Tracing;
+
+    /**
+     * Sends a `keydown`, `keypress/input`, and `keyup` event for each character in the text.
+     * @param selector A selector of an element to type into. If there are multiple elements satisfying the selector, the first will be used.
+     * @param text: A text to type into a focused element.
+     * @param options: The typing parameters.
+     */
+    type(selector: string, text: string, options?: { delay: number, ... }): Promise<void>;
+
+    /**
+     * The page's URL. This is a shortcut for `page.mainFrame().url()`
+     */
+    +url: () => string;
+
+    /** Gets the page viewport. */
+    viewport(): Viewport;
+
+    /**
+     * Wait for the page navigation occur.
+     * @param options The navigation parameters.
+     */
+    waitForNavigation(options?: NavigationOptions): Promise<Response>;
+  }
+
+  /** A Browser is created when Puppeteer connects to a Chromium instance, either through puppeteer.launch or puppeteer.connect. */
+  declare export interface Browser extends OverridableEventEmitter {
+    /**
+     * Closes browser with all the pages (if any were opened).
+     * The browser object itself is considered to be disposed and can not be used anymore.
+     */
+    close(): Promise<void>;
+
+    /**
+     * Disconnects Puppeteer from the browser, but leaves the Chromium process running.
+     * After calling `disconnect`, the browser object is considered disposed and cannot be used anymore.
+     */
+    disconnect(): void;
+
+    /** Promise which resolves to a new Page object. */
+    newPage(): Promise<Page>;
+
+    /**
+     * Adds the listener function to the end of the listeners array for the event named `eventName`.
+     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
+     * `eventName` and listener will result in the listener being added, and called, multiple times.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    on<K: BrowserEvents>(
+      eventName: K,
+      handler: (e: $ElementType<BrowserEventObj, K>, ...args: Array<mixed>) => void
+    ): Browser;
+
+    /**
+     * Adds a one time listener function for the event named `eventName`.
+     * The next time `eventName` is triggered, this listener is removed and then invoked.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    once<K: BrowserEvents>(
+      eventName: K,
+      handler: (e: $ElementType<BrowserEventObj, K>, ...args: Array<mixed>) => void
+    ): Browser;
+
+    /** Promise which resolves to an array of all open pages. */
+    pages(): Promise<Array<Page>>;
+
+    /** Spawned browser process. Returns `null` if the browser instance was created with `puppeteer.connect` method */
+    process(): ChildProcess;
+
+    /** Promise which resolves to an array of all active targets. */
+    targets(): Promise<Array<Target>>;
+
+    /**
+     * Promise which resolves to the browser's original user agent.
+     * **NOTE** Pages can override browser user agent with `page.setUserAgent`.
+     */
+    userAgent(): Promise<string>;
+
+    /** For headless Chromium, this is similar to HeadlessChrome/61.0.3153.0. For non-headless, this is similar to Chrome/61.0.3153.0. */
+    version(): Promise<string>;
+
+    /** Browser websocket endpoint which can be used as an argument to puppeteer.connect. The format is ws://${host}:${port}/devtools/browser/<id> */
+    wsEndpoint(): string;
+  }
+
+  declare export type BrowserEventObj = {
+   /** Emitted when puppeteer gets disconnected from the browser instance. */
+   disconnected: void,
+   /** Emitted when the url of a target changes. */
+   targetchanged: Target,
+   /** Emitted when a target is created, for example when a new page is opened by `window.open` or `browser.newPage`. */
+   targetcreated: Target,
+   /** Emitted when a target is destroyed, for example when a page is closed. */
+   targetdestroyed: Target,
+   ...
+  };
+
+  declare export type Target = {
+   /** Creates a Chrome Devtools Protocol session attached to the target. */
+   createCDPSession(): Promise<CDPSession>,
+   /** Returns the target `Page` or a `null` if the type of the page is not "page". */
+   page(): Promise<Page>,
+   /** Identifies what kind of target this is.  */
+   type(): 'page' | 'service_worker' | 'other',
+   /** Returns the target URL. */
+   url(): string,
+   ...
+  };
+
+  declare export type LaunchOptions = {
+   /** Whether to open chrome in appMode. Defaults to false. */
+   appMode?: boolean,
+   /**
+    * Additional arguments to pass to the Chromium instance. List of Chromium
+    * flags can be found here.
+    */
+   args?: Array<string>,
+   /** Whether to auto-open DevTools panel for each tab. If this option is true, the headless option will be set false. */
+   devtools?: boolean,
+   /**
+    * Whether to pipe browser process stdout and stderr into process.stdout and
+    * process.stderr. Defaults to false.
+    */
+   dumpio?: boolean,
+   /** Specify environment variables that will be visible to Chromium. Defaults to process.env. */
+   env?: mixed,
+   /**
+    * Path to a Chromium executable to run instead of bundled Chromium. If
+    * executablePath is a relative path, then it is resolved relative to current
+    * working directory.
+    */
+   executablePath?: string,
+   /** Close chrome process on SIGHUP. Defaults to true. */
+   handleSIGHUP?: boolean,
+   /** Close chrome process on Ctrl-C. Defaults to true. */
+   handleSIGINT?: boolean,
+   /** Close chrome process on SIGTERM. Defaults to true. */
+   handleSIGTERM?: boolean,
+   /** Whether to run Chromium in headless mode. Defaults to true. */
+   headless?: boolean,
+   /** Do not use `puppeteer.defaultArgs()` for launching Chromium. Defaults to false. */
+   ignoreDefaultArgs?: boolean,
+   /** Whether to ignore HTTPS errors during navigation. Defaults to false. */
+   ignoreHTTPSErrors?: boolean,
+   /**
+    * Slows down Puppeteer operations by the specified amount of milliseconds.
+    * Useful so that you can see what is going on.
+    */
+   slowMo?: number,
+   /**
+    * Maximum time in milliseconds to wait for the Chrome instance to start.
+    * Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
+    */
+   timeout?: number,
+   /** Path to a User Data Directory. */
+   userDataDir?: string,
+   ...
+  };
+
+  declare export type ConnectOptions = {
+   /** A browser websocket endpoint to connect to. */
+   browserWSEndpoint?: string,
+   /**
+    * Whether to ignore HTTPS errors during navigation.
+    * @default false
+    */
+   ignoreHTTPSErrors?: boolean,
+   ...
+  };
+
+  declare export interface CDPSession extends events$EventEmitter {
+    /**
+     * Detaches session from target. Once detached, session won't emit any events and can't be used
+     * to send messages.
+     */
+    detach(): Promise<void>;
+
+    /**
+     * @param method Protocol method name
+     */
+    // eslint-disable-next-line flowtype/no-weak-types
+    send(method: string, params?: Object): Promise<mixed>;
+  }
+
+  declare export type Coverage = {
+   startCSSCoverage(options?: StartCoverageOptions): Promise<void>,
+   startJSCoverage(options?: StartCoverageOptions): Promise<void>,
+   stopCSSCoverage(): Promise<Array<CoverageEntry>>,
+   stopJSCoverage(): Promise<Array<CoverageEntry>>,
+   ...
+  };
+
+  declare export type StartCoverageOptions = { /** Whether to reset coverage on every navigation. Defaults to `true`. */
+  resetOnNavigation?: boolean, ... };
+
+  declare export type CoverageEntry = {
+   ranges: Array<{
+    end: number,
+    start: number,
+    ...
+   }>,
+   text: string,
+   url: string,
+   ...
+  };
+
+  declare export default {
+    /** Attaches Puppeteer to an existing Chromium instance */
+    connect: (options?: ConnectOptions) => Promise<Browser>;
+    /** The default flags that Chromium will be launched with */
+    defaultArgs: () => Array<string>;
+    /** Path where Puppeteer expects to find bundled Chromium */
+    executablePath: () => string;
+    /** The method launches a browser instance with given arguments. The browser will be closed when the parent node.js process is closed. */
+    launch: (options?: LaunchOptions) => Promise<Browser>;
+    ...
+  }
+}
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_connect.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_connect.js
similarity index 100%
rename from definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_connect.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_connect.js
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_defaultArgs.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_defaultArgs.js
similarity index 100%
rename from definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_defaultArgs.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_defaultArgs.js
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_executablePath.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_executablePath.js
similarity index 100%
rename from definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_executablePath.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_executablePath.js
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_launch.js b/definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_launch.js
similarity index 100%
rename from definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/test_puppeteer_v13.x.x_launch.js
rename to definitions/npm/puppeteer_v1.20.x/flow_v0.201.x-/test_puppeteer_v1.20.x_launch.js
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/puppeteer_v13.x.x.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/puppeteer_v13.x.x.js
similarity index 100%
rename from definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-/puppeteer_v13.x.x.js
rename to definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/puppeteer_v13.x.x.js
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_connect.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_connect.js
new file mode 100644
index 0000000000..7596875aed
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_connect.js
@@ -0,0 +1,53 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.connect', () => {
+  it('should complain if you pass in a string arg', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with `ConnectOptions`
+    puppeteer.connect('testing...');
+  });
+  it('should complain if an option arg key is of the wrong type', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with boolean in property `ignoreHTTPSErrors`
+    puppeteer.connect({ ignoreHTTPSErrors: 'testing...' });
+  });
+  it('should preserve Browser type', () => {
+    puppeteer.connect().then(browser => {
+      // $FlowExpectedError[incompatible-call] string is incompatible with enum
+      browser.on('response');
+      browser.newPage().then(page => {
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+      });
+      browser.on('targetcreated', target => {
+        target.createCDPSession().then(cdpSession => {
+          // $FlowExpectedError[prop-missing] property `connect` is missing in `CDPSession`
+          cdpSession.connect();
+          cdpSession.detach();
+        });
+      });
+    });
+  });
+  it('should preserve Page type', () => {
+    puppeteer.connect().then(browser =>
+      browser.newPage().then(page => {
+        // $FlowExpectedError[incompatible-call] string is incompatible with enum in type argument `K`
+        page.on('testing...');
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+        page.on('response', response => {
+          response.request().url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Response`
+          response.testing();
+        });
+      })
+    );
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_defaultArgs.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_defaultArgs.js
new file mode 100644
index 0000000000..380ad69253
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_defaultArgs.js
@@ -0,0 +1,14 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.defaultArgs', () => {
+  it('should return a string array', () => {
+    (puppeteer.defaultArgs(): Array<string>);
+  });
+  it('should complain if passed args', () => {
+    // $FlowExpectedError[extra-arg] no arguments are expected by function type
+    (puppeteer.defaultArgs('testing...'): Array<string>);
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_executablePath.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_executablePath.js
new file mode 100644
index 0000000000..039e627f1c
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_executablePath.js
@@ -0,0 +1,14 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.executablePath', () => {
+  it('should return a string', () => {
+    (puppeteer.executablePath(): string);
+  });
+  it('should complain if passed args', () => {
+    // $FlowExpectedError[extra-arg] no arguments are expected by function type
+    (puppeteer.executablePath('testing...'): string);
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_launch.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_launch.js
new file mode 100644
index 0000000000..daf0ae3035
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.104.x-v0.200.x/test_puppeteer_v13.x.x_launch.js
@@ -0,0 +1,46 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.launch', () => {
+  it('should complain if you pass in a string arg', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with `LaunchOptions`
+    puppeteer.launch('testing...');
+  });
+  it('should complain if an option arg key is of the wrong type', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with boolean inproperty `headless`
+    puppeteer.launch({ headless: 'testing...' });
+  });
+  it('should preserve the Browser type', () => {
+    puppeteer.launch().then(browser => {
+      // $FlowExpectedError[incompatible-call] string is incompatible with enum
+      browser.on('response');
+      browser.newPage().then(page => {
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+      });
+    });
+  });
+  it('should preserver Page type through launch, etc.', () => {
+    puppeteer.launch().then(browser =>
+      browser.newPage().then(page => {
+        // $FlowExpectedError[incompatible-call] string is incompatible with enum in type argument `K`
+        page.on('testing...');
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+        page.on('response', response => {
+          response.request().url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Response`
+          response.testing();
+        });
+      })
+    );
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/puppeteer_v13.x.x.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/puppeteer_v13.x.x.js
new file mode 100644
index 0000000000..5eb0f10dd3
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/puppeteer_v13.x.x.js
@@ -0,0 +1,1372 @@
+// @flow
+
+/**
+ * Based on typescript definitions found at the url below
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/puppeteer
+ */
+
+declare module 'puppeteer' {
+  import type { ChildProcess } from 'child_process';
+
+  declare class OverridableEventEmitter extends events$EventEmitter {
+    /* eslint-disable flowtype/no-weak-types */
+    +on: Function;
+    +once: Function;
+    /* eslint-enable flowtype/no-weak-types */
+  }
+
+  /** Keyboard provides an api for managing a virtual keyboard. */
+  declare export type Keyboard = {
+   /**
+    * Dispatches a keydown event.
+    * @param key Name of key to press, such as ArrowLeft.
+    * @param options Specifies a input text event.
+    */
+   down(key: string, options?: { text?: string, ... }): Promise<void>,
+   /** Shortcut for `keyboard.down` and `keyboard.up`. */
+   press(key: string, options?: {
+    delay?: number,
+    text?: string,
+    ...
+   }): Promise<void>,
+   /** Dispatches a `keypress` and `input` event. This does not send a `keydown` or keyup `event`. */
+   sendCharacter(char: string): Promise<void>,
+   /**
+    * Sends a keydown, keypress/input, and keyup event for each character in the text.
+    * @param text A text to type into a focused element.
+    * @param options Specifies the typing options.
+    */
+   type(text: string, options?: { delay?: number, ... }): Promise<void>,
+   /**
+    * Dispatches a keyup event.
+    * @param key Name of key to release, such as ArrowLeft.
+    */
+   up(key: string): Promise<void>,
+   ...
+  };
+
+  declare export type MousePressOptions = {
+   /**
+    * left, right, or middle.
+    * @default left
+    */
+   button?: MouseButtons,
+   /**
+    * The number of clicks.
+    * @default 1
+    */
+   clickCount?: number,
+   ...
+  };
+
+  declare export type Mouse = {
+   /**
+    * Shortcut for `mouse.move`, `mouse.down` and `mouse.up`.
+    * @param x The x position.
+    * @param y The y position.
+    * @param options The click options.
+    */
+   click(x: number, y: number, options?: ClickOptions): Promise<void>,
+   /**
+    * Dispatches a `mousedown` event.
+    * @param options The mouse press options.
+    */
+   down(options?: MousePressOptions): Promise<void>,
+   /**
+    * Dispatches a `mousemove` event.
+    * @param x The x position.
+    * @param y The y position.
+    * @param options The mouse move options.
+    */
+   move(x: number, y: number, options?: { steps: number, ... }): Promise<void>,
+   /**
+    * Dispatches a `mouseup` event.
+    * @param options The mouse press options.
+    */
+   up(options?: MousePressOptions): Promise<void>,
+   ...
+  };
+
+  declare export type Touchscreen = { /**
+   * Dispatches a touchstart and touchend event.
+   * @param x The x position.
+   * @param y The y position.
+   */
+  tap(x: number, y: number): Promise<void>, ... };
+
+  /**
+   * You can use `tracing.start` and `tracing.stop` to create a trace file which can be opened in Chrome DevTools or timeline viewer.
+   */
+  declare export type Tracing = {
+   start(options: TracingStartOptions): Promise<void>,
+   stop(): Promise<void>,
+   ...
+  };
+
+  declare export type TracingStartOptions = {
+   categories?: Array<string>,
+   path: string,
+   screenshots?: boolean,
+   ...
+  };
+
+  /** Dialog objects are dispatched by page via the 'dialog' event. */
+  declare export type Dialog = {
+   /**
+    * Accepts the dialog.
+    * @param promptText A text to enter in prompt. Does not cause any effects if the dialog's type is not prompt.
+    */
+   accept(promptText?: string): Promise<void>,
+   /** If dialog is prompt, returns default prompt value. Otherwise, returns empty string. */
+   defaultValue(): string,
+   /** Dismiss the dialog */
+   dismiss(): Promise<void>,
+   /** Returns the message displayed in the dialog. */
+   message(): string,
+   /** The dialog type. Dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`. */
+   type(): 'alert' | 'beforeunload' | 'confirm' | 'prompt',
+   ...
+  };
+
+  /** ConsoleMessage objects are dispatched by page via the 'console' event. */
+  declare export type ConsoleMessage = {
+   /** The message arguments. */
+   args(): Array<JSHandle>,
+   /** The message text. */
+   text(): string,
+   type():
+     | 'log'
+     | 'debug'
+     | 'info'
+     | 'error'
+     | 'warning'
+     | 'dir'
+     | 'dirxml'
+     | 'table'
+     | 'trace'
+     | 'clear'
+     | 'startGroup'
+     | 'startGroupCollapsed'
+     | 'endGroup'
+     | 'assert'
+     | 'profile'
+     | 'profileEnd'
+     | 'count'
+     | 'timeEnd',
+   ...
+  };
+
+  declare export type PageEvents =
+    | 'console'
+    | 'dialog'
+    | 'error'
+    | 'frameattached'
+    | 'framedetached'
+    | 'framenavigated'
+    | 'load'
+    | 'pageerror'
+    | 'request'
+    | 'requestfailed'
+    | 'requestfinished'
+    | 'response';
+
+  declare export type BrowserEvents =
+    | 'disconnected'
+    | 'targetchanged'
+    | 'targetcreated'
+    | 'targetdestroyed';
+
+  declare export type AuthOptions = {
+   password: string,
+   username: string,
+   ...
+  };
+
+  declare export type MouseButtons = 'left' | 'right' | 'middle';
+
+  declare export type ClickOptions = {
+   /** defaults to left */
+   button?: MouseButtons,
+   /** defaults to 1 */
+   clickCount?: number,
+   /**
+    * Time to wait between mousedown and mouseup in milliseconds.
+    * Defaults to 0.
+    */
+   delay?: number,
+   ...
+  };
+
+  /** Represents a browser cookie. */
+  declare export type Cookie = {
+   /** The cookie domain. */
+   domain: string,
+   /** The cookie Unix expiration time in seconds. */
+   expires: number,
+   /** The cookie http only flag. */
+   httpOnly: boolean,
+   /** The cookie name. */
+   name: string,
+   /** The cookie path. */
+   path: string,
+   /** The cookie same site definition. */
+   sameSite: 'Strict' | 'Lax',
+   /** The cookie secure flag. */
+   secure: boolean,
+   /** The cookie value. */
+   value: string,
+   ...
+  };
+
+  declare export type DeleteCookie = {
+   domain?: string,
+   /** The cookie name. */
+   name: string,
+   path?: string,
+   secure?: boolean,
+   url?: string,
+   ...
+  };
+
+  declare export type SetCookie = {
+   /** The cookie domain. */
+   domain?: string,
+   /** The cookie Unix expiration time in seconds. */
+   expires?: number,
+   /** The cookie http only flag. */
+   httpOnly?: boolean,
+   /** The cookie name. */
+   name: string,
+   /** The cookie path. */
+   path?: string,
+   /** The cookie same site definition. */
+   sameSite?: 'Strict' | 'Lax',
+   /** The cookie secure flag. */
+   secure?: boolean,
+   /** The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie. */
+   url?: string,
+   /** The cookie value. */
+   value: string,
+   ...
+  };
+
+  declare export type Viewport = {
+   /**
+    * Specify device scale factor (can be thought of as dpr).
+    * @default 1
+    */
+   deviceScaleFactor?: number,
+   /**
+    * Specifies if viewport supports touch events.
+    * @default false
+    */
+   hasTouch?: boolean,
+   /** The page height in pixels. */
+   height: number,
+   /**
+    * Specifies if viewport is in landscape mode.
+    * @default false
+    */
+   isLandscape?: boolean,
+   /**
+    * Whether the `meta viewport` tag is taken into account.
+    * @default false
+    */
+   isMobile?: boolean,
+   /** The page width in pixels. */
+   width: number,
+   ...
+  };
+
+  /** Page emulation options. */
+  declare export type EmulateOptions = {
+   /** The emulated user-agent. */
+   userAgent?: string,
+   /** The viewport emulation options. */
+   viewport?: Viewport,
+   ...
+  };
+
+  declare export type EvaluateFn = string | ((...args: Array<mixed>) => mixed);
+
+  declare export type LoadEvent = 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+
+  /** The navigation options. */
+  declare export type NavigationOptions = {
+   /**
+    * Maximum navigation time in milliseconds, pass 0 to disable timeout.
+    * @default 30000
+    */
+   timeout?: number,
+   /**
+    * When to consider navigation succeeded.
+    * @default load Navigation is consider when the `load` event is fired.
+    */
+   waitUntil?: LoadEvent | Array<LoadEvent>,
+   ...
+  };
+
+  declare export type PDFFormat =
+    | 'Letter'
+    | 'Legal'
+    | 'Tabload'
+    | 'Ledger'
+    | 'A0'
+    | 'A1'
+    | 'A2'
+    | 'A3'
+    | 'A4'
+    | 'A5';
+
+  declare export type PDFOptions = {
+   /**
+    * Display header and footer.
+    * @default false
+    */
+   displayHeaderFooter?: boolean,
+   /**
+    * HTML template for the print footer. Should be valid HTML markup with following classes used to inject printing values into them:
+    * - `date` formatted print date
+    * - `title` document title
+    * - `url` document location
+    * - `pageNumber` current page number
+    * - `totalPages` total pages in the document
+    */
+   footerTemplate?: string,
+   /** Paper format. If set, takes priority over width or height options. Defaults to 'Letter'. */
+   format?: PDFFormat,
+   /**
+    * HTML template for the print header. Should be valid HTML markup with following classes used to inject printing values into them:
+    * - `date` formatted print date
+    * - `title` document title
+    * - `url` document location
+    * - `pageNumber` current page number
+    * - `totalPages` total pages in the document
+    */
+   headerTemplate?: string,
+   /** Paper height, accepts values labeled with units. */
+   height?: string,
+   /**
+    * Paper orientation.
+    * @default false
+    */
+   landscape?: boolean,
+   /** Paper margins, defaults to none.  */
+   margin?: {
+    /** Bottom margin, accepts values labeled with units. */
+    bottom?: string,
+    /** Left margin, accepts values labeled with units. */
+    left?: string,
+    /** Right margin, accepts values labeled with units. */
+    right?: string,
+    /** Top margin, accepts values labeled with units. */
+    top?: string,
+    ...
+   },
+   /**
+    * Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty
+    * string, which means print all pages.
+    */
+   pageRanges?: string,
+   /**
+    * The file path to save the PDF to.
+    * If `path` is a relative path, then it is resolved relative to current working directory.
+    * If no path is provided, the PDF won't be saved to the disk.
+    */
+   path?: string,
+   /**
+    * Print background graphics.
+    * @default false
+    */
+   printBackground?: boolean,
+   /**
+    * Scale of the webpage rendering.
+    * @default 1
+    */
+   scale?: number,
+   /** Paper width, accepts values labeled with units. */
+   width?: string,
+   ...
+  };
+
+  /** Defines the screenshot options. */
+  declare export type ScreenshotOptions = {
+   /**
+    * An object which specifies clipping region of the page.
+    */
+   clip?: BoundingBox,
+   /**
+    * When true, takes a screenshot of the full scrollable page.
+    * @default false
+    */
+   fullPage?: boolean,
+   /**
+    * Hides default white background and allows capturing screenshots with transparency.
+    * @default false
+    */
+   omitBackground?: boolean,
+   /**
+    * The file path to save the image to. The screenshot type will be inferred from file extension.
+    * If `path` is a relative path, then it is resolved relative to current working directory.
+    * If no path is provided, the image won't be saved to the disk.
+    */
+   path?: string,
+   /** The quality of the image, between 0-100. Not applicable to png images. */
+   quality?: number,
+   /**
+    * The screenshot type.
+    * @default png
+    */
+   type?: 'jpeg' | 'png',
+   ...
+  };
+
+  /** Options for `addStyleTag` */
+  declare export type StyleTagOptions = {
+   /** Raw CSS content to be injected into frame. */
+   content?: string,
+   /** Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
+   path?: string,
+   /** Url of the <link> tag. */
+   url?: string,
+   ...
+  };
+  /** Options for `addScriptTag` */
+  declare export type ScriptTagOptions = {
+   /** Raw JavaScript content to be injected into frame. */
+   content?: string,
+   /** Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory. */
+   path?: string,
+   /** Script type. Use 'module' in order to load a Javascript ES6 module. */
+   type?: string,
+   /** Url of a script to be added. */
+   url?: string,
+   ...
+  };
+
+  declare export type PageFnOptions = {
+   polling?: 'raf' | 'mutation' | number,
+   timeout?: number,
+   ...
+  };
+
+  declare export type BoundingBox = {
+   /** The height. */
+   height: number,
+   /** The width. */
+   width: number,
+   /** The x-coordinate of top-left corner. */
+   x: number,
+   /** The y-coordinate of top-left corner. */
+   y: number,
+   ...
+  };
+
+  /**
+   * Represents an in-page DOM element. ElementHandles can be created with the page.$ method.
+   */
+  declare export type ElementHandle = JSHandle & {
+   /**
+    * The method runs element.querySelector within the page. If no element matches the selector, the return value resolve to null.
+    * @param selector A selector to query element for
+    * @since 0.13.0
+    */
+   $(selector: string): Promise<ElementHandle | null>,
+   /**
+    * The method runs element.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
+    * @param selector A selector to query element for
+    * @since 0.13.0
+    */
+   $$(selector: string): Promise<Array<ElementHandle>>,
+   /**
+    * @param selector XPath expression to evaluate.
+    */
+   $x(expression: string): Promise<Array<ElementHandle>>,
+   /**
+    * This method returns the value resolve to the bounding box of the element (relative to the main frame), or null if the element is not visible.
+    */
+   boundingBox(): Promise<BoundingBox | null>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.mouse to click in the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    * @param options Specifies the options.
+    * @since 0.9.0
+    */
+   click(options?: ClickOptions): Promise<void>,
+   /**
+    * @returns Resolves to the content frame for element handles referencing iframe nodes, or null otherwise.
+    * @since 1.2.0
+    */
+   contentFrame(): Promise<?Frame>,
+   /**
+    * Calls focus on the element.
+    */
+   focus(): Promise<void>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.mouse to hover over the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    */
+   hover(): Promise<void>,
+   /**
+    * Focuses the element, and then uses keyboard.down and keyboard.up.
+    * @param key Name of key to press, such as ArrowLeft. See USKeyboardLayout for a list of all key names.
+    * @param options The text and delay options.
+    */
+   press(key: string, options?: {
+    delay?: number,
+    text?: string,
+    ...
+   }): Promise<void>,
+   /**
+    * This method scrolls element into view if needed, and then uses page.screenshot to take a screenshot of the element.
+    * If the element is detached from DOM, the method throws an error.
+    * @param options Same options as in page.screenshot.
+    */
+   screenshot(options?: ScreenshotOptions): Promise<Buffer>,
+   /**
+    * This method scrolls element into view if needed, and then uses touchscreen.tap to tap in the center of the element.
+    * If the element is detached from DOM, the method throws an error.
+    */
+   tap(): Promise<void>,
+   toString(): string,
+   /**
+    * Focuses the element, and then sends a keydown, keypress/input, and keyup event for each character in the text.
+    * @param text A text to type into a focused element.
+    * @param options The typing options.
+    */
+   type(text: string, options?: { delay: number, ... }): Promise<void>,
+   /**
+    * This method expects elementHandle to point to an input element.
+    * @param filePaths Sets the value of the file input these paths. If some of the filePaths are relative paths, then they are resolved relative to current working directory.
+    */
+   uploadFile(...filePaths: Array<string>): Promise<void>,
+   ...
+  };
+
+  /** The class represents a context for JavaScript execution. */
+  declare export type ExecutionContext = {
+   evaluate(fn: EvaluateFn, ...args: Array<mixed>): Promise<mixed>,
+   evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>,
+   queryObjects(prototypeHandle: JSHandle): JSHandle,
+   ...
+  };
+
+  /** JSHandle represents an in-page JavaScript object. */
+  declare export type JSHandle = {
+   /**
+    * Returns a ElementHandle
+    */
+   asElement(): ElementHandle | null,
+   /**
+    * Stops referencing the element handle.
+    */
+   dispose(): Promise<void>,
+   /**
+    * Gets the execution context.
+    */
+   executionContext(): ExecutionContext,
+   /**
+    * Returns a map with property names as keys and JSHandle instances for the property values.
+    */
+   getProperties(): Promise<Map<string, JSHandle>>,
+   /**
+    * Fetches a single property from the objectHandle.
+    * @param propertyName The property to get.
+    */
+   getProperty(propertyName: string): Promise<JSHandle>,
+   /**
+    * Returns a JSON representation of the object.
+    * The JSON is generated by running JSON.stringify on the object in page and consequent JSON.parse in puppeteer.
+    * @throws The method will throw if the referenced object is not stringifiable.
+    */
+   jsonValue(): Promise<mixed>,
+   ...
+  };
+
+  declare export type Metrics = {
+   /** Number of documents in the page. */
+   Documents: number,
+   /** Number of frames in the page. */
+   Frames: number,
+   /** Number of events in the page. */
+   JSEventListeners: number,
+   /** Total JavaScript heap size. */
+   JSHeapTotalSize: number,
+   /** Used JavaScript heap size. */
+   JSHeapUsedSize: number,
+   /** Total number of full or partial page layout. */
+   LayoutCount: number,
+   /** Combined durations of all page layouts. */
+   LayoutDuration: number,
+   /** Number of DOM nodes in the page. */
+   Nodes: number,
+   /** Total number of page style recalculations. */
+   RecalcStyleCount: number,
+   /** Combined duration of all page style recalculations. */
+   RecalcStyleDuration: number,
+   /** Combined duration of JavaScript execution. */
+   ScriptDuration: number,
+   /** Combined duration of all tasks performed by the browser. */
+   TaskDuration: number,
+   /** The timestamp when the metrics sample was taken. */
+   Timestamp: number,
+   ...
+  };
+
+  declare export type Headers = { [key: string]: string, ... };
+  declare export type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE' | 'OPTIONS';
+
+  declare export type ResourceType =
+    | 'document'
+    | 'stylesheet'
+    | 'image'
+    | 'media'
+    | 'font'
+    | 'script'
+    | 'texttrack'
+    | 'xhr'
+    | 'fetch'
+    | 'eventsource'
+    | 'websocket'
+    | 'manifest'
+    | 'other';
+
+  declare export type Overrides = {
+   headers?: Headers,
+   method?: HttpMethod,
+   postData?: string,
+   url?: string,
+   ...
+  };
+
+  /** Represents a page request. */
+  declare export type Request = {
+   /**
+    * Aborts request.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    */
+   abort(): Promise<void>,
+   /**
+    * Continues request with optional request overrides.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    */
+   continue(overrides?: Overrides): Promise<void>,
+   /**
+    * @returns The `Frame` object that initiated the request, or `null` if navigating to error pages
+    */
+   frame(): Promise<?Frame>,
+   /**
+    * An object with HTTP headers associated with the request.
+    * All header names are lower-case.
+    */
+   headers(): Headers,
+   /** Returns the request's method (GET, POST, etc.) */
+
+   method(): HttpMethod,
+   /** Contains the request's post body, if any. */
+   postData(): ?string,
+   /**
+    * A `redirectChain` is a chain of requests initiated to fetch a resource.
+    *
+    * - If there are no redirects and the request was successful, the chain will be empty.
+    * - If a server responds with at least a single redirect, then the chain will contain all the requests that were redirected.
+    *
+    * `redirectChain` is shared between all the requests of the same chain.
+    *
+    * @since 1.2.0
+    */
+   redirectChain(): Array<Request>,
+   /** Contains the request's resource type as it was perceived by the rendering engine.  */
+   resourceType(): ResourceType,
+   /**
+    * Fulfills request with given response.
+    * To use this, request interception should be enabled with `page.setRequestInterception`.
+    * @throws An exception is immediately thrown if the request interception is not enabled.
+    * @param response The response options that will fulfill this request.
+    */
+   respond(response: RespondOptions): Promise<void>,
+   /** A matching `Response` object, or `null` if the response has not been received yet. */
+   response(): ?Response,
+   /** Contains the URL of the request. */
+   url(): string,
+   ...
+  };
+
+  /** Options for `Request.respond` method */
+  declare export type RespondOptions = {
+   /** Specifies the response body. */
+   body?: Buffer | string,
+   /** Specifies the Content-Type response header. */
+   contentType?: string,
+   /** Specifies the response headers. */
+   headers?: Headers,
+   /**
+    * Specifies the response status code.
+    * @default 200
+    */
+   status?: number,
+   ...
+  };
+
+  /** Response class represents responses which are received by page. */
+  declare export type Response = {
+   /** Promise which resolves to a buffer with response body. */
+   buffer(): Promise<Buffer>,
+   /** True if the response was served from either the browser's disk cache or memory cache. */
+   fromCache(): boolean,
+   /** True if the response was served by a service worker. */
+   fromServiceWorker(): boolean,
+   /** An object with HTTP headers associated with the response. All header names are lower-case. */
+   headers(): Headers,
+   /**
+    * Promise which resolves to a JSON representation of response body.
+    * @throws This method will throw if the response body is not parsable via `JSON.parse`.
+    */
+   json(): Promise<mixed>,
+   /** Contains a boolean stating whether the response was successful (status in the range 200-299) or not. */
+   ok(): boolean,
+   /** A matching Request object. */
+   request(): Request,
+   /** Contains the status code of the response (e.g., 200 for a success). */
+   status(): number,
+   /** Promise which resolves to a text representation of response body. */
+   text(): Promise<string>,
+   /** Contains the URL of the response. */
+   url(): string,
+   ...
+  };
+
+  declare class FrameBase {
+    /**
+     * The method runs document.querySelector within the page.
+     * If no element matches the selector, the return value resolve to null.
+     */
+    $: (selector: string) => Promise<?ElementHandle>;
+
+    /**
+     * The method runs document.querySelectorAll within the page. If no elements match the selector, the return value resolve to [].
+     */
+    $$: (selector: string) => Promise<Array<ElementHandle>>;
+
+    /**
+     * This method runs document.querySelectorAll within the page and passes it as the first argument to `fn`.
+     * If `fn` returns a Promise, then $$eval would wait for the promise to resolve and return its value.
+     * @param selector A selector to query frame for
+     * @param fn Function to be evaluated in browser context
+     * @param args Arguments to pass to pageFunction
+     * @returns Promise which resolves to the return value of pageFunction
+     */
+    $$eval: (
+      selector: string,
+      pageFunction: (
+        elements: NodeList<Element>,
+        ...args: Array<mixed>
+      ) => mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    /**
+     * This method runs document.querySelector within the page and passes it as the first argument to `fn`.
+     * If there's no element matching selector, the method throws an error.
+     * If `fn` returns a Promise, then $eval would wait for the promise to resolve and return its value.
+     */
+    $eval: (
+      selector: string,
+      pageFunction: (element: Element, ...args: Array<mixed>) => mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    /**
+     * @param expression XPath expression to evaluate.
+     */
+    $x: (expression: string) => Promise<Array<ElementHandle>>;
+
+    /** Adds a `<script>` tag into the page with the desired url or content. */
+    addScriptTag: (options: ScriptTagOptions) => Promise<void>;
+
+    /** Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content. */
+    addStyleTag: (options: StyleTagOptions) => Promise<void>;
+
+    /** Gets the full HTML contents of the page, including the doctype. */
+    content: () => Promise<string>;
+
+    /**
+     * Evaluates a function in the browser context.
+     * If the function, passed to the frame.evaluate, returns a Promise, then frame.evaluate would wait for the promise to resolve and return its value.
+     * If the function passed into frame.evaluate returns a non-Serializable value, then frame.evaluate resolves to undefined.
+     * @param fn Function to be evaluated in browser context
+     * @param args Arguments to pass to `fn`
+     */
+    evaluate: (fn: EvaluateFn, ...args: Array<mixed>) => Promise<mixed>;
+
+    /**
+     * Sets the page content.
+     * @param html HTML markup to assign to the page.
+     */
+    setContent: (html: string) => Promise<void>;
+
+    /** Returns page's title. */
+    +title: () => Promise<string>;
+
+    /** Returns frame's url. */
+    +url: () => string;
+
+    waitFor: (
+      // fn can be an abritary function
+      // eslint-disable-next-line flowtype/no-weak-types
+      selectorOrFunctionOrTimeout: string | number | Function,
+      options?: mixed,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    waitForFunction: (
+      // fn can be an abritary function
+      // eslint-disable-next-line flowtype/no-weak-types
+      fn: string | Function,
+      options?: PageFnOptions,
+      ...args: Array<mixed>
+    ) => Promise<mixed>;
+
+    waitForSelector: (
+      selector: string,
+      options?: {
+       hidden?: boolean,
+       timeout?: number,
+       visible?: boolean,
+       ...
+      }
+    ) => Promise<ElementHandle>;
+  }
+
+  declare export type Frame = FrameBase & {
+   childFrames(): Array<Frame>,
+   /** Execution context associated with this frame. */
+   executionContext(): ExecutionContext,
+   /** Returns `true` if the frame has been detached, or `false` otherwise. */
+   isDetached(): boolean,
+   /** Returns frame's name attribute as specified in the tag. */
+   name(): string,
+   /** Returns parent frame, if any. Detached frames and main frames return null. */
+   parentFrame(): ?Frame,
+   ...
+  };
+
+  declare export type PageEventObj = {
+   /**
+    * Emitted when JavaScript within the page calls one of console API methods, e.g. console.log or console.dir.
+    * Also emitted if the page throws an error or a warning.
+    */
+   console: ConsoleMessage,
+   /**
+    * Emitted when a JavaScript dialog appears, such as alert, prompt, confirm or beforeunload.
+    * Puppeteer can respond to the dialog via Dialog's accept or dismiss methods.
+    */
+   dialog: Dialog,
+   /** Emitted when the page crashes. */
+   error: Error,
+   /** Emitted when a frame is attached. */
+   frameattached: Frame,
+   /** Emitted when a frame is detached. */
+   framedetached: Frame,
+   /** Emitted when a frame is navigated to a new url. */
+   framenavigated: Frame,
+   /** Emitted when the JavaScript load event is dispatched. */
+   load: void,
+   /**
+    * Emitted when the JavaScript code makes a call to `console.timeStamp`.
+    * For the list of metrics see `page.metrics`.
+    */
+   metrics: {
+    metrics: mixed,
+    title: string,
+    ...
+   },
+   /** Emitted when an uncaught exception happens within the page. */
+   pageerror: string,
+   /**
+    * Emitted when a page issues a request. The request object is read-only.
+    * In order to intercept and mutate requests, see page.setRequestInterceptionEnabled.
+    */
+   request: Request,
+   /** Emitted when a request fails, for example by timing out. */
+   requestfailed: Request,
+   /** Emitted when a request finishes successfully. */
+   requestfinished: Request,
+   /** Emitted when a response is received. */
+   response: Response,
+   ...
+  };
+
+  /** Page provides methods to interact with a single tab in Chromium. One Browser instance might have multiple Page instances. */
+  declare export interface Page extends OverridableEventEmitter, FrameBase {
+    /**
+     * Provide credentials for http authentication.
+     * To disable authentication, pass `null`.
+     */
+    authenticate(credentials: AuthOptions | null): Promise<void>;
+
+    /** Brings page to front (activates tab). */
+    bringToFront(): Promise<void>;
+
+    /**
+     * This method fetches an element with selector, scrolls it into view if needed, and
+     * then uses `page.mouse` to click in the center of the element. If there's no element
+     * matching selector, the method throws an error.
+     * @param selector A selector to search for element to click. If there are multiple elements satisfying the selector, the first will be clicked.
+     * @param options Specifies the click options.
+     */
+    click(selector: string, options?: ClickOptions): Promise<void>;
+
+    /** Closes the current page. */
+    close(): Promise<void>;
+
+    /**
+     * Gets the cookies.
+     * If no URLs are specified, this method returns cookies for the current page URL.
+     * If URLs are specified, only cookies for those URLs are returned.
+     */
+    cookies(...urls: Array<string>): Promise<Array<Cookie>>;
+
+    coverage: Coverage;
+
+    /**
+     * Deletes the specified cookies.
+     */
+    deleteCookie(...cookies: Array<DeleteCookie>): Promise<void>;
+
+    /** Emulates given device metrics and user agent. This method is a shortcut for `setUserAgent` and `setViewport`.  */
+    emulate(options: $Shape<EmulateOptions>): Promise<void>;
+
+    /** Emulates the media. */
+    emulateMedia(mediaType: 'screen' | 'print' | null): Promise<void>;
+
+    /**
+     * Evaluates a function in the page context.
+     * If the function, passed to the page.evaluateHandle, returns a Promise, then page.evaluateHandle
+     * would wait for the promise to resolve and return its value.
+     * @param fn The function to be evaluated in the page context.
+     * @param args The arguments to pass to the `fn`.
+     * @returns A promise which resolves to return value of `fn`.
+     */
+    evaluateHandle(fn: EvaluateFn, ...args: Array<mixed>): Promise<JSHandle>;
+
+    /**
+     * Adds a function which would be invoked in one of the following scenarios: whenever the page is navigated; whenever the child frame is attached or navigated.
+     * The function is invoked after the document was created but before any of its scripts were run. This is useful to amend JavaScript environment, e.g. to seed Math.random.
+     * @param fn The function to be evaluated in browser context.
+     * @param args The arguments to pass to the `fn`.
+     */
+    evaluateOnNewDocument(fn: EvaluateFn, ...args: Array<mixed>): Promise<void>;
+
+    /**
+     * The method adds a function called name on the page's `window` object.
+     * When called, the function executes `puppeteerFunction` in node.js and returns a
+     * Promise which resolves to the return value of `puppeteerFunction`.
+     * @param name The name of the function on the window object.
+     * @param fn Callback function which will be called in Puppeteer's context.
+     */
+    exposeFunction(
+      name: string,
+      puppeteerFunction: (...args: Array<mixed>) => mixed
+    ): Promise<void>;
+
+    /** This method fetches an element with selector and focuses it. */
+    focus(selector: string): Promise<void>;
+
+    /** An array of all frames attached to the page. */
+    frames(): Array<Frame>;
+
+    /**
+     * Navigate to the previous page in history.
+     * @param options The navigation parameters.
+     */
+    goBack(options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * Navigate to the next page in history.
+     * @param options The navigation parameters.
+     */
+    goForward(options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * Navigates to a URL.
+     * @param url URL to navigate page to. The url should include scheme, e.g. `https://`
+     * @param options The navigation parameters.
+     */
+    goto(url: string, options?: $Shape<NavigationOptions>): Promise<Response | null>;
+
+    /**
+     * This method fetches an element with `selector`, scrolls it into view if needed,
+     * and then uses page.mouse to hover over the center of the element. If there's no
+     * element matching `selector`, the method throws an error.
+     * @param selector A selector to search for element to hover. If there are multiple elements satisfying the selector, the first will be hovered.
+     */
+    hover(selector: string): Promise<void>;
+
+    /** Returns the virtual keyboard. */
+    keyboard: Keyboard;
+
+    /** Page is guaranteed to have a main frame which persists during navigation's. */
+    mainFrame(): Frame;
+
+    /** Gets the page metrics. */
+    metrics(): Promise<Metrics>;
+
+    /** Gets the virtual mouse. */
+    mouse: Mouse;
+
+    /**
+     * Adds the listener function to the end of the listeners array for the event named `eventName`.
+     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
+     * `eventName` and listener will result in the listener being added, and called, multiple times.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    on<K: PageEvents>(
+      eventName: K,
+      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
+    ): Page;
+
+    /**
+     * Adds a one time listener function for the event named `eventName`.
+     * The next time `eventName` is triggered, this listener is removed and then invoked.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    once<K: PageEvents>(
+      eventName: K,
+      handler: (e: $ElementType<PageEventObj, K>, ...args: Array<mixed>) => void
+    ): Page;
+
+    /**
+     * Generates a PDF of the page with `print` css media.
+     * To generate a pdf with `screen` media, call `page.emulateMedia('screen')` before calling `page.pdf()`:
+     * @param options The PDF parameters.
+     */
+    pdf(options?: $Shape<PDFOptions>): Promise<Buffer>;
+
+    /**
+     * The method iterates JavaScript heap and finds all the objects with the given prototype.
+     * @param prototypeHandle A handle to the object prototype.
+     */
+    queryObjects(prototypeHandle: JSHandle): Promise<JSHandle>;
+
+    /**
+     * Reloads the current page.
+     * @param options The navigation parameters.
+     */
+    reload(options?: NavigationOptions): Promise<Response>;
+
+    /**
+     * Captures a screenshot of the page.
+     * @param options The screenshot options.
+     */
+    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
+
+    /**
+     * Triggers a `change` and `input` event once all the provided options have been selected.
+     * If there's no `<select>` element matching selector, the method throws an error.
+     * @param selector A selector to query page for.
+     * @param values Values of options to select. If the `<select>` has the `multiple` attribute,
+     * all values are considered, otherwise only the first one is taken into account.
+     */
+    select(selector: string, ...values: Array<string>): Promise<Array<string>>;
+
+    /**
+     * Determines whether cache is enabled on the page.
+     * @param enabled Whether or not to enable cache on the page.
+     */
+    setCacheEnabled(enabled: boolean): Promise<void>;
+
+    /**
+     * Sets the cookies on the page.
+     * @param cookies The cookies to set.
+     */
+    setCookie(...cookies: Array<SetCookie>): Promise<void>;
+
+    /**
+     * This setting will change the default maximum navigation time of 30 seconds for the following methods:
+     * - `page.goto`
+     * - `page.goBack`
+     * - `page.goForward`
+     * - `page.reload`
+     * - `page.waitForNavigation`
+     */
+    setDefaultNavigationTimeout(timeout: number): void;
+
+    /**
+     * The extra HTTP headers will be sent with every request the page initiates.
+     * @param headers An object containing additional http headers to be sent with every request. All header values must be strings.
+     */
+    setExtraHTTPHeaders(headers: Headers): Promise<void>;
+
+    /**
+     * Determines whether JavaScript is enabled on the page.
+     * @param enable Whether or not to enable JavaScript on the page.
+     */
+    setJavaScriptEnabled(enabled: boolean): Promise<void>;
+
+    /**
+     * Determines whether the offline mode is enabled.
+     * @param enabled When `true`, enables the offline mode for the page.
+     */
+    setOfflineMode(enabled: boolean): Promise<void>;
+
+    /**
+     * Determines whether the request interception is enabled.
+     * @param enabled When `true` the methods `request.abort`, `request.continue` and `request.respond` must be used.
+     */
+    setRequestInterception(enabled: boolean): Promise<void>;
+
+    /**
+     * Specifies the User-Agent used in this page.
+     * @param userAgent The user-agent to be used in the page.
+     */
+    setUserAgent(userAgent: string): Promise<void>;
+
+    /**
+     * Sets the viewport of the page.
+     * @param viewport The viewport parameters.
+     */
+    setViewport(viewport: Viewport): Promise<void>;
+
+    /**
+     * This method fetches an element with `selector`, scrolls it into view if needed,
+     * and then uses page.touchscreen to tap in the center of the element.
+     * @param selector A `selector` to search for element to tap. If there are multiple elements
+     * satisfying the selector, the first will be tapped.
+     */
+    tap(selector: string): Promise<void>;
+
+    /** @returns The target this page was created from */
+    target(): Target;
+
+    /** Returns the page's title. */
+    +title: () => Promise<string>;
+
+    /** Returns the virtual touchscreen object. */
+    touchscreen: Touchscreen;
+
+    /** Returns the tracing object. */
+    tracing: Tracing;
+
+    /**
+     * Sends a `keydown`, `keypress/input`, and `keyup` event for each character in the text.
+     * @param selector A selector of an element to type into. If there are multiple elements satisfying the selector, the first will be used.
+     * @param text: A text to type into a focused element.
+     * @param options: The typing parameters.
+     */
+    type(selector: string, text: string, options?: { delay: number, ... }): Promise<void>;
+
+    /**
+     * The page's URL. This is a shortcut for `page.mainFrame().url()`
+     */
+    +url: () => string;
+
+    /** Gets the page viewport. */
+    viewport(): Viewport;
+
+    /**
+     * Wait for the page navigation occur.
+     * @param options The navigation parameters.
+     */
+    waitForNavigation(options?: NavigationOptions): Promise<Response>;
+  }
+
+  /** A Browser is created when Puppeteer connects to a Chromium instance, either through puppeteer.launch or puppeteer.connect. */
+  declare export interface Browser extends OverridableEventEmitter {
+    /**
+     * Closes browser with all the pages (if any were opened).
+     * The browser object itself is considered to be disposed and can not be used anymore.
+     */
+    close(): Promise<void>;
+
+    /**
+     * Disconnects Puppeteer from the browser, but leaves the Chromium process running.
+     * After calling `disconnect`, the browser object is considered disposed and cannot be used anymore.
+     */
+    disconnect(): void;
+
+    /** Promise which resolves to a new Page object. */
+    newPage(): Promise<Page>;
+
+    /**
+     * Adds the listener function to the end of the listeners array for the event named `eventName`.
+     * No checks are made to see if the listener has already been added. Multiple calls passing the same combination of
+     * `eventName` and listener will result in the listener being added, and called, multiple times.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    on<K: BrowserEvents>(
+      eventName: K,
+      handler: (e: $ElementType<BrowserEventObj, K>, ...args: Array<mixed>) => void
+    ): Browser;
+
+    /**
+     * Adds a one time listener function for the event named `eventName`.
+     * The next time `eventName` is triggered, this listener is removed and then invoked.
+     * @param event The name of the event.
+     * @param handler The callback function.
+     */
+    once<K: BrowserEvents>(
+      eventName: K,
+      handler: (e: $ElementType<BrowserEventObj, K>, ...args: Array<mixed>) => void
+    ): Browser;
+
+    /** Promise which resolves to an array of all open pages. */
+    pages(): Promise<Array<Page>>;
+
+    /** Spawned browser process. Returns `null` if the browser instance was created with `puppeteer.connect` method */
+    process(): ChildProcess;
+
+    /** Promise which resolves to an array of all active targets. */
+    targets(): Promise<Array<Target>>;
+
+    /**
+     * Promise which resolves to the browser's original user agent.
+     * **NOTE** Pages can override browser user agent with `page.setUserAgent`.
+     */
+    userAgent(): Promise<string>;
+
+    /** For headless Chromium, this is similar to HeadlessChrome/61.0.3153.0. For non-headless, this is similar to Chrome/61.0.3153.0. */
+    version(): Promise<string>;
+
+    /** Browser websocket endpoint which can be used as an argument to puppeteer.connect. The format is ws://${host}:${port}/devtools/browser/<id> */
+    wsEndpoint(): string;
+  }
+
+  declare export type BrowserEventObj = {
+   /** Emitted when puppeteer gets disconnected from the browser instance. */
+   disconnected: void,
+   /** Emitted when the url of a target changes. */
+   targetchanged: Target,
+   /** Emitted when a target is created, for example when a new page is opened by `window.open` or `browser.newPage`. */
+   targetcreated: Target,
+   /** Emitted when a target is destroyed, for example when a page is closed. */
+   targetdestroyed: Target,
+   ...
+  };
+
+  declare export type Target = {
+   /** Creates a Chrome Devtools Protocol session attached to the target. */
+   createCDPSession(): Promise<CDPSession>,
+   /** Returns the target `Page` or a `null` if the type of the page is not "page". */
+   page(): Promise<Page>,
+   /** Identifies what kind of target this is.  */
+   type(): 'page' | 'service_worker' | 'other',
+   /** Returns the target URL. */
+   url(): string,
+   ...
+  };
+
+  declare export type LaunchOptions = {
+   /** Whether to open chrome in appMode. Defaults to false. */
+   appMode?: boolean,
+   /**
+    * Additional arguments to pass to the Chromium instance. List of Chromium
+    * flags can be found here.
+    */
+   args?: Array<string>,
+   /** Whether to auto-open DevTools panel for each tab. If this option is true, the headless option will be set false. */
+   devtools?: boolean,
+   /**
+    * Whether to pipe browser process stdout and stderr into process.stdout and
+    * process.stderr. Defaults to false.
+    */
+   dumpio?: boolean,
+   /** Specify environment variables that will be visible to Chromium. Defaults to process.env. */
+   env?: mixed,
+   /**
+    * Path to a Chromium executable to run instead of bundled Chromium. If
+    * executablePath is a relative path, then it is resolved relative to current
+    * working directory.
+    */
+   executablePath?: string,
+   /** Close chrome process on SIGHUP. Defaults to true. */
+   handleSIGHUP?: boolean,
+   /** Close chrome process on Ctrl-C. Defaults to true. */
+   handleSIGINT?: boolean,
+   /** Close chrome process on SIGTERM. Defaults to true. */
+   handleSIGTERM?: boolean,
+   /** Whether to run Chromium in headless mode. Defaults to true. */
+   headless?: boolean,
+   /** Do not use `puppeteer.defaultArgs()` for launching Chromium. Defaults to false. */
+   ignoreDefaultArgs?: boolean,
+   /** Whether to ignore HTTPS errors during navigation. Defaults to false. */
+   ignoreHTTPSErrors?: boolean,
+   /**
+    * Slows down Puppeteer operations by the specified amount of milliseconds.
+    * Useful so that you can see what is going on.
+    */
+   slowMo?: number,
+   /**
+    * Maximum time in milliseconds to wait for the Chrome instance to start.
+    * Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
+    */
+   timeout?: number,
+   /** Path to a User Data Directory. */
+   userDataDir?: string,
+   ...
+  };
+
+  declare export type ConnectOptions = {
+   /** A browser websocket endpoint to connect to. */
+   browserWSEndpoint?: string,
+   /**
+    * Whether to ignore HTTPS errors during navigation.
+    * @default false
+    */
+   ignoreHTTPSErrors?: boolean,
+   ...
+  };
+
+  declare export interface CDPSession extends events$EventEmitter {
+    /**
+     * Detaches session from target. Once detached, session won't emit any events and can't be used
+     * to send messages.
+     */
+    detach(): Promise<void>;
+
+    /**
+     * @param method Protocol method name
+     */
+    // eslint-disable-next-line flowtype/no-weak-types
+    send(method: string, params?: Object): Promise<mixed>;
+  }
+
+  declare export type Coverage = {
+   startCSSCoverage(options?: StartCoverageOptions): Promise<void>,
+   startJSCoverage(options?: StartCoverageOptions): Promise<void>,
+   stopCSSCoverage(): Promise<Array<CoverageEntry>>,
+   stopJSCoverage(): Promise<Array<CoverageEntry>>,
+   ...
+  };
+
+  declare export type StartCoverageOptions = { /** Whether to reset coverage on every navigation. Defaults to `true`. */
+  resetOnNavigation?: boolean, ... };
+
+  declare export type CoverageEntry = {
+   ranges: Array<{
+    end: number,
+    start: number,
+    ...
+   }>,
+   text: string,
+   url: string,
+   ...
+  };
+
+  declare module.exports: {
+    /** Attaches Puppeteer to an existing Chromium instance */
+    connect: (options?: ConnectOptions) => Promise<Browser>;
+    /** The default flags that Chromium will be launched with */
+    defaultArgs: () => Array<string>;
+    /** Path where Puppeteer expects to find bundled Chromium */
+    executablePath: () => string;
+    /** The method launches a browser instance with given arguments. The browser will be closed when the parent node.js process is closed. */
+    launch: (options?: LaunchOptions) => Promise<Browser>;
+    ...
+  }
+}
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_connect.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_connect.js
new file mode 100644
index 0000000000..7596875aed
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_connect.js
@@ -0,0 +1,53 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.connect', () => {
+  it('should complain if you pass in a string arg', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with `ConnectOptions`
+    puppeteer.connect('testing...');
+  });
+  it('should complain if an option arg key is of the wrong type', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with boolean in property `ignoreHTTPSErrors`
+    puppeteer.connect({ ignoreHTTPSErrors: 'testing...' });
+  });
+  it('should preserve Browser type', () => {
+    puppeteer.connect().then(browser => {
+      // $FlowExpectedError[incompatible-call] string is incompatible with enum
+      browser.on('response');
+      browser.newPage().then(page => {
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+      });
+      browser.on('targetcreated', target => {
+        target.createCDPSession().then(cdpSession => {
+          // $FlowExpectedError[prop-missing] property `connect` is missing in `CDPSession`
+          cdpSession.connect();
+          cdpSession.detach();
+        });
+      });
+    });
+  });
+  it('should preserve Page type', () => {
+    puppeteer.connect().then(browser =>
+      browser.newPage().then(page => {
+        // $FlowExpectedError[incompatible-call] string is incompatible with enum in type argument `K`
+        page.on('testing...');
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+        page.on('response', response => {
+          response.request().url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Response`
+          response.testing();
+        });
+      })
+    );
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_defaultArgs.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_defaultArgs.js
new file mode 100644
index 0000000000..380ad69253
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_defaultArgs.js
@@ -0,0 +1,14 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.defaultArgs', () => {
+  it('should return a string array', () => {
+    (puppeteer.defaultArgs(): Array<string>);
+  });
+  it('should complain if passed args', () => {
+    // $FlowExpectedError[extra-arg] no arguments are expected by function type
+    (puppeteer.defaultArgs('testing...'): Array<string>);
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_executablePath.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_executablePath.js
new file mode 100644
index 0000000000..039e627f1c
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_executablePath.js
@@ -0,0 +1,14 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.executablePath', () => {
+  it('should return a string', () => {
+    (puppeteer.executablePath(): string);
+  });
+  it('should complain if passed args', () => {
+    // $FlowExpectedError[extra-arg] no arguments are expected by function type
+    (puppeteer.executablePath('testing...'): string);
+  });
+});
diff --git a/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_launch.js b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_launch.js
new file mode 100644
index 0000000000..daf0ae3035
--- /dev/null
+++ b/definitions/npm/puppeteer_v13.x.x/flow_v0.201.x-/test_puppeteer_v13.x.x_launch.js
@@ -0,0 +1,46 @@
+// @flow
+
+import puppeteer from 'puppeteer';
+import { describe, it } from 'flow-typed-test';
+
+describe('puppeteer.launch', () => {
+  it('should complain if you pass in a string arg', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with `LaunchOptions`
+    puppeteer.launch('testing...');
+  });
+  it('should complain if an option arg key is of the wrong type', () => {
+    // $FlowExpectedError[incompatible-call] string is incompatible with boolean inproperty `headless`
+    puppeteer.launch({ headless: 'testing...' });
+  });
+  it('should preserve the Browser type', () => {
+    puppeteer.launch().then(browser => {
+      // $FlowExpectedError[incompatible-call] string is incompatible with enum
+      browser.on('response');
+      browser.newPage().then(page => {
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+      });
+    });
+  });
+  it('should preserver Page type through launch, etc.', () => {
+    puppeteer.launch().then(browser =>
+      browser.newPage().then(page => {
+        // $FlowExpectedError[incompatible-call] string is incompatible with enum in type argument `K`
+        page.on('testing...');
+        page.on('request', request => {
+          request.url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Request`
+          request.testing();
+        });
+        page.on('response', response => {
+          response.request().url();
+          // $FlowExpectedError[prop-missing] property `testing` is missing in `Response`
+          response.testing();
+        });
+      })
+    );
+  });
+});
diff --git a/definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-/react-hot-loader_v4.6.x.js b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-v0.200.x/react-hot-loader_v4.6.x.js
similarity index 100%
rename from definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-/react-hot-loader_v4.6.x.js
rename to definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-v0.200.x/react-hot-loader_v4.6.x.js
diff --git a/definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-/test_react-hot-loader_4.6.x.js b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-v0.200.x/test_react-hot-loader_4.6.x.js
similarity index 100%
rename from definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-/test_react-hot-loader_4.6.x.js
rename to definitions/npm/react-hot-loader_v4.6.x/flow_v0.104.x-v0.200.x/test_react-hot-loader_4.6.x.js
diff --git a/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/react-hot-loader_v4.6.x.js b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/react-hot-loader_v4.6.x.js
new file mode 100644
index 0000000000..ded130dafd
--- /dev/null
+++ b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/react-hot-loader_v4.6.x.js
@@ -0,0 +1,55 @@
+// @flow
+declare module "react-hot-loader" {
+  declare type Module = { id: string, ... };
+
+  declare type ErrorReporterProps = {|
+    error: Error,
+    errorInfo: { componentStack: string, ... }
+  |}
+
+  declare export type ContainerProps = {|
+    children: React$Element<any>,
+    errorBoundary?: boolean,
+    errorReporter?: React$ComponentType<ErrorReporterProps>,
+  |}
+
+  declare export class AppContainer extends React$Component<ContainerProps> {}
+
+  declare export function hot(module: Module): <T: React$ComponentType<any>>(
+    Component: T,
+    props?: $Diff<ContainerProps, { children: React$Element<any>, ... }>
+  ) => T
+
+  declare export function cold<T: React$ComponentType<any>>(component: T): T
+
+  declare export function areComponentsEqual<T>(
+    typeA: React$ComponentType<T>,
+    typeB: React$ComponentType<T>
+  ): boolean
+
+  declare type Config = {|
+    logLevel: 'debug' | 'log' | 'warn' | 'error',
+    pureSFC: boolean,
+    pureRender: boolean,
+    allowSFC: boolean,
+    disableHotRenderer: boolean,
+    disableHotRendererWhenInjected: boolean,
+    ignoreSFC: boolean,
+    ignoreComponents: boolean,
+    errorReporter: React$ComponentType<ErrorReporterProps>,
+    ErrorOverlay: React$ComponentType<{ errors: Array<ErrorReporterProps>, ... }>,
+    onComponentRegister: (type: any, uniqueLocalName: string, fileName: string) => any,
+    onComponentCreate: (type: any, displayName: string) => any,
+  |}
+
+  declare export function setConfig(config: $Shape<Config>): void
+}
+
+declare module "react-hot-loader/root" {
+  import type { ContainerProps } from 'react-hot-loader';
+
+  declare export function hot<T: React$ComponentType<any>>(
+    Component: T,
+    props?: $Diff<ContainerProps, { children: React$Element<any>, ... }>
+  ): T;
+}
diff --git a/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/test_react-hot-loader_4.6.x.js b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/test_react-hot-loader_4.6.x.js
new file mode 100644
index 0000000000..252025c83d
--- /dev/null
+++ b/definitions/npm/react-hot-loader_v4.6.x/flow_v0.201.x-/test_react-hot-loader_4.6.x.js
@@ -0,0 +1,218 @@
+// @flow
+import * as React from "react";
+import { describe, it } from "flow-typed-test";
+
+import { AppContainer, hot, setConfig, areComponentsEqual, cold } from "react-hot-loader";
+import { hot as rootHot } from "react-hot-loader/root";
+
+describe("react-hot-loader", () => {
+  describe("AppContainer", () => {
+    it("accepts only one child", () => {
+      <AppContainer>
+        <div />
+      </AppContainer>;
+
+      const SomeComponent = () => null;
+      <AppContainer>
+        <SomeComponent />
+      </AppContainer>;
+
+      // $FlowExpectedError
+      <AppContainer />;
+
+      // $FlowExpectedError
+      <AppContainer>
+        <div />
+        <div />
+      </AppContainer>;
+    });
+
+    it("accepts an optional errorBoundary flag", () => {
+      <AppContainer errorBoundary>
+        <div />
+      </AppContainer>;
+
+      <AppContainer errorBoundary={false}>
+        <div />
+      </AppContainer>;
+
+      // $FlowExpectedError
+      <AppContainer errorBoundary={1}>
+        <div />
+      </AppContainer>;
+    });
+
+    it("accepts an optional error reporting component that optionally accepts error and errorInfo", () => {
+      let ErrorReporter;
+
+      ErrorReporter = () => <div />;
+      <AppContainer errorReporter={ErrorReporter}>
+        <div />
+      </AppContainer>;
+
+      ErrorReporter = ({ error }: { error: Error, ... }) => <div />;
+      <AppContainer errorReporter={ErrorReporter}>
+        <div />
+      </AppContainer>;
+
+      ErrorReporter = ({
+        errorInfo
+      }: { errorInfo: { componentStack: string, ... }, ... }) => <div />;
+      <AppContainer errorReporter={ErrorReporter}>
+        <div />
+      </AppContainer>;
+
+      // $FlowExpectedError
+      <AppContainer errorReporter={null}>
+        <div />
+      </AppContainer>;
+
+      // $FlowExpectedError
+      ErrorReporter = ({ error }: { error: number, ... }) => <div />;
+      <AppContainer errorReporter={ErrorReporter}>
+        <div />
+      </AppContainer>;
+    });
+  });
+
+  describe("hot", () => {
+    it("accepts some module", () => {
+      hot(module);
+
+      // $FlowExpectedError
+      hot();
+
+      // $FlowExpectedError
+      hot({});
+    });
+
+    it("returns a helper for wrapping a component in AppContainer", () => {
+      const Wrapped = () => <div />;
+
+      hot(module)(Wrapped);
+      hot(module)(Wrapped, {});
+      hot(module)(Wrapped, { errorBoundary: true });
+
+      // $FlowExpectedError
+      hot(module)();
+
+      // $FlowExpectedError
+      hot(module)(Wrapped, { errorBoundary: 1 });
+    });
+
+    it("returned component accepts same props as the wrapped component", () => {
+      const Wrapped = ({ someProp }: $Exact<{ someProp: string, ... }>) => <div />;
+
+      const Component = hot(module)(Wrapped);
+
+      <Component someProp={"some"} />;
+
+      // $FlowExpectedError
+      <Component />;
+
+      // $FlowExpectedError
+      <Component someProp={1} />;
+    });
+  });
+
+  describe("cold", () => {
+    it('pass wrong parameters', () => {
+      const Component1 = () => <div />;
+
+      cold(Component1);
+
+      // $FlowExpectedError
+      cold({});
+
+      // $FlowExpectedError
+      cold(1);
+
+      // $FlowExpectedError
+      cold(true);
+
+      // $FlowExpectedError
+      cold(<div />);
+    });
+  });
+
+  describe("areComponentsEqual", () => {
+    it('pass wrong parameters', () => {
+      const Component1 = () => <div />;
+      const Component2 = () => <div />;
+      const Component3 = () => <div />;
+
+      areComponentsEqual(Component1, Component2);
+
+      // $FlowExpectedError
+      areComponentsEqual(Component1, {});
+
+      // $FlowExpectedError
+      areComponentsEqual(1, Component2);
+
+      // $FlowExpectedError
+      areComponentsEqual(Component1, true);
+
+      // $FlowExpectedError
+      areComponentsEqual(Component1, Component2, Component3);
+    });
+  });
+
+  describe("setConfig", () => {
+    it('can use', () => {
+      setConfig({
+        logLevel: 'error',
+        errorReporter: ({ error }: { error: Error, ... }) => <div />,
+        ErrorOverlay: () => null,
+      });
+    });
+
+    it('can pass partial config', () => {
+      setConfig({
+        pureSFC: false,
+        allowSFC: true,
+        ignoreSFC: false,
+      });
+    });
+
+    it('error when type not match', () => {
+      // $FlowExpectedError
+      setConfig({
+        logLevel: 'my value',
+        pureSFC: 1,
+        ignoreSFC: 0,
+      });
+    });
+  });
+});
+
+describe("react-hot-loader/root", () => {
+  describe("hot", () => {
+    it("returns a helper for wrapping a component in AppContainer", () => {
+      const Wrapped = () => <div />;
+
+      rootHot(Wrapped);
+      rootHot(Wrapped, {});
+      rootHot(Wrapped, { errorBoundary: true });
+
+      // $FlowExpectedError
+      rootHot();
+
+      // $FlowExpectedError
+      rootHot(Wrapped, { errorBoundary: 1 });
+    });
+
+    it("returned component accepts same props as the wrapped component", () => {
+      const Wrapped = ({ someProp }: $Exact<{ someProp: string, ... }>) => <div />;
+
+      const Component = rootHot(Wrapped);
+
+      <Component someProp={"some"} />;
+
+      // $FlowExpectedError
+      <Component />;
+
+      // $FlowExpectedError
+      <Component someProp={1} />;
+    });
+  });
+});
diff --git a/definitions/npm/react-jss_v7.x.x/flow_v0.53.x-/react-jss_v7.x.x.js b/definitions/npm/react-jss_v7.x.x/flow_v0.201.x-/react-jss_v7.x.x.js
similarity index 100%
rename from definitions/npm/react-jss_v7.x.x/flow_v0.53.x-/react-jss_v7.x.x.js
rename to definitions/npm/react-jss_v7.x.x/flow_v0.201.x-/react-jss_v7.x.x.js
diff --git a/definitions/npm/react-jss_v7.x.x/flow_v0.53.x-v0.200.x/react-jss_v7.x.x.js b/definitions/npm/react-jss_v7.x.x/flow_v0.53.x-v0.200.x/react-jss_v7.x.x.js
new file mode 100644
index 0000000000..e1919f147a
--- /dev/null
+++ b/definitions/npm/react-jss_v7.x.x/flow_v0.53.x-v0.200.x/react-jss_v7.x.x.js
@@ -0,0 +1,80 @@
+declare module 'react-jss' {
+  /*
+    P = Props
+    OP = OwnProps
+    Def = DefaultProps
+    St = State
+  */
+
+  declare type Null = null | void;
+
+  declare type Dictionary = { [key: string]: {} };
+
+  declare type StatelessComponent<P> = (props: P) => ?React$Element<any>;
+
+  declare type ClassComponent<Def, P, St> = Class<React$Component<P, St>>;
+
+  declare class ConnectedComponent<OP, P, Def, St> extends React$Component<OP, St> {
+    static InnerComponent: Class<React$Component<P, St>>;
+    static defaultProps: void;
+    props: OP;
+    state: St;
+  }
+
+  declare type ConnectedComponentClass<OP, P, Def, St> = Class<ConnectedComponent<OP, P, Def, St>>;
+
+  declare type Connector<OP, P> = {
+    (component: StatelessComponent<P>): ConnectedComponentClass<OP, P, void, void>,
+    <Def, St>(component: ClassComponent<Def, P, St>): ConnectedComponentClass<OP, P, Def, St>,
+    (component: Null): ConnectedComponentClass<OP, P, void, void>,
+  };
+
+  declare export type Classes<Styles> = { [classname: $Keys<Styles>]: string };
+
+  declare export type Sheet<Styles> = {
+    attached: boolean,
+    classes: Classes<Styles>,
+    deployed: boolean,
+    linked: boolean,
+    options: Object,
+    renderer: mixed,
+    rules: mixed,
+  };
+
+  declare type InjectedProps<Styles> = {
+    classes: Classes<Styles>,
+    sheet: Sheet<Styles>,
+    theme?: Dictionary,
+  };
+
+  declare type Theme = Dictionary | ((parentTheme: Theme) => Dictionary);
+
+  declare type StylesCreatorFn<S> = (theme: Theme) => S;
+
+  declare export default function injectSheet<OP, Styles: Dictionary>(
+    stylesOrCreator: StylesCreatorFn<Styles> | Styles,
+  ): Connector<OP, $Shape<InjectedProps<Styles> & OP>>;
+
+  // TODO: improve `JssProvider` type
+  declare export class JssProvider extends React$Component<any, any> {}
+
+  // TODO: improve `ThemeProvider` type
+  declare export class ThemeProvider extends React$Component<any, any> {}
+
+  declare export function withTheme<ThemeType, OP>(
+    component: StatelessComponent<$Shape<{ theme: ThemeType } & OP>>,
+  ): ConnectedComponentClass<OP, $Shape<{ theme: ThemeType } & OP>, void, void>;
+
+  declare export function withTheme<ThemeType, OP, Def, St>(
+    component: ClassComponent<Def, $Shape<{ theme: ThemeType } & OP>, St>,
+  ): ConnectedComponentClass<OP, $Shape<{ theme: ThemeType } & OP>, Def, St>;
+
+  declare export function createTheming(
+    customChannel: string,
+  ): {
+    channel: string,
+    withTheme: Function,
+    ThemeProvider: ThemeProvider,
+    themeListener: {},
+  };
+}
diff --git a/definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-/react-native-video_v3.x.x.js b/definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-v0.200.x/react-native-video_v3.x.x.js
similarity index 100%
rename from definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-/react-native-video_v3.x.x.js
rename to definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-v0.200.x/react-native-video_v3.x.x.js
diff --git a/definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-/test_react-native-video.js b/definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-v0.200.x/test_react-native-video.js
similarity index 100%
rename from definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-/test_react-native-video.js
rename to definitions/npm/react-native-video_v3.x.x/flow_v0.104.x-v0.200.x/test_react-native-video.js
diff --git a/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/react-native-video_v3.x.x.js b/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/react-native-video_v3.x.x.js
new file mode 100644
index 0000000000..84af5f9245
--- /dev/null
+++ b/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/react-native-video_v3.x.x.js
@@ -0,0 +1,160 @@
+declare module "react-native-video" {
+  // https://github.com/react-native-community/react-native-video/blob/master/TextTrackType.js#L3-L6
+
+  // iOS only supports VTT, Android ExoPlayer supports all 3
+  declare export type TextTrackTypes = {
+    SRT: "application/x-subrip",
+    TTML: "application/ttml+xml",
+    VTT: "text/vtt",
+    ...
+  };
+
+  declare export var TextTrackType: TextTrackTypes;
+
+  declare export type TrackType = $Values<TextTrackTypes>;
+
+  declare export type TrackDescriptor = {|
+    title?: ?string,
+    uri: string,
+    type: TrackType,
+    language: string
+  |};
+
+  // https://github.com/react-native-community/react-native-video#selectedaudiotrack
+  declare export type SelectedTrackDescriptor =
+    | {|
+        type: "system",
+        value?: any
+      |}
+    | {|
+        type: "disabled",
+        value?: any
+      |}
+    | {|
+        type: "title",
+        value: string
+      |}
+    | {|
+        type: "language",
+        value: string
+      |}
+    | {|
+        type: "index",
+        value: number
+      |};
+
+  declare export type BufferConfigDescriptor = {|
+    minBufferMs?: ?number,
+    maxBufferMs?: ?number,
+    bufferForPlaybackMs?: ?number,
+    bufferForPlaybackAfterRebufferMs?: ?number
+  |};
+
+  declare export type Event<T: {...}> = $ReadOnly<{|
+    target: number,
+    ...$Exact<T>
+  |}>;
+
+  declare export type LoadEvent = Event<
+    $ReadOnly<{
+      audioTracks: $ReadOnlyArray<TrackDescriptor>,
+      canPlayFastForward: boolean,
+      canPlayReverse: boolean,
+      canPlaySlowForward: boolean,
+      canPlaySlowReverse: boolean,
+      canStepBackward: boolean,
+      canStepForward: boolean,
+      currentTime: number,
+      duration: number,
+      naturalSize: $ReadOnly<{|
+        height: number,
+        orientation: string,
+        width: number
+      |}>,
+      textTracks: $ReadOnlyArray<TrackDescriptor>,
+      ...
+    }>
+  >;
+
+  declare export type ProgressEvent = Event<{|
+    +currentTime: number,
+    +playableDuration: number,
+    +seekableDuration: number
+  |}>;
+
+  declare export type AudioFocusChangedEvent = Event<{ +hasAudioFocus: boolean, ... }>;
+
+  declare export type BufferEvent = Event<{ +isBuffering: boolean, ... }>;
+
+  declare export type LoadStartEvent = Event<{
+    +isNetwork: boolean,
+    +type: string,
+    +uri: string,
+    ...
+  }>;
+
+  declare export type TimedMetadata = {| +value: string, +identifier: string |};
+  declare export type TimedMetadataEvent = Event<{ +metadata: $ReadOnlyArray<TimedMetadata>, ... }>;
+
+  declare export type VideoProps = {
+    source: number | {| uri: string |},
+    // https://github.com/react-native-community/react-native-video/blob/master/VideoResizeMode.js#L4-L6
+    resizeMode?: ?("contain" | "cover" | "stretch"),
+    poster?: ?string,
+    // https://github.com/facebook/react-native/blob/master/Libraries/Image/ImageProps.js#L71
+    posterResizeMode?: ?("cover" | "contain" | "stretch" | "repeat" | "center"),
+    repeat?: ?boolean,
+    allowsExternalPlayback?: ?boolean,
+    selectedAudioTrack?: SelectedTrackDescriptor,
+    selectedTextTrack?: SelectedTrackDescriptor,
+    textTracks?: Array<TrackDescriptor>,
+    paused?: ?boolean,
+    muted?: ?boolean,
+    volume?: ?number,
+    bufferConfig?: BufferConfigDescriptor,
+    stereoPan?: ?number,
+    rate?: ?number,
+    playInBackground?: ?boolean,
+    playWhenInactive?: ?boolean,
+    ignoreSilentSwitch?: ?("ignore" | "obey"),
+    disableFocus?: ?boolean,
+    controls?: ?boolean,
+    audioOnly?: ?boolean,
+    currentTime?: ?number,
+    progressUpdateInterval?: ?number,
+    useTextureView?: ?boolean,
+    onLoadStart?: ?(LoadStartEvent) => void,
+    onLoad?: ?(LoadEvent) => void,
+    onBuffer?: ?(BufferEvent) => void,
+    onError?: ?Function,
+    onProgress?: ?(ProgressEvent) => void,
+    onSeek?: ?Function,
+    onEnd?: ?Function,
+    onFullscreenPlayerWillPresent?: ?Function,
+    onFullscreenPlayerDidPresent?: ?Function,
+    onFullscreenPlayerWillDismiss?: ?Function,
+    onFullscreenPlayerDidDismiss?: ?Function,
+    onReadyForDisplay?: ?Function,
+    onPlaybackStalled?: ?Function,
+    onPlaybackResume?: ?Function,
+    onPlaybackRateChange?: ?Function,
+    onAudioFocusChanged?: ?(AudioFocusChangedEvent) => void,
+    onAudioBecomingNoisy?: ?Function,
+    onTimedMetadata?: ?(TimedMetadataEvent) => void,
+    /* Required by react-native */
+    scaleX?: ?number,
+    scaleY?: ?number,
+    translateX?: ?number,
+    translateY?: ?number,
+    rotation?: ?number,
+    ...
+  };
+
+  declare export default class Video extends React$Component<VideoProps> {
+    dismissFullscreenPlayer(): void;
+    presentFullscreenPlayer(): void;
+    // Tolerance is the max distance in milliseconds from the seconds position that's allowed. (tolerance supported on iOS)
+    seek(seconds: number, toleranceIOS?: number): void;
+    setNativeProps(params: $Shape<VideoProps>): void;
+  }
+}
diff --git a/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/test_react-native-video.js b/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/test_react-native-video.js
new file mode 100644
index 0000000000..ff8707211f
--- /dev/null
+++ b/definitions/npm/react-native-video_v3.x.x/flow_v0.201.x-/test_react-native-video.js
@@ -0,0 +1,391 @@
+// @flow
+import * as React from "react";
+import { describe, it } from "flow-typed-test";
+import Video, {
+  TextTrackType,
+  type TimedMetadata,
+  type TrackDescriptor
+} from "react-native-video";
+
+describe("selectedAudioTrack & selectedTextTrack", () => {
+  it("must passes when used properly", () => {
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "system" }}
+      selectedTextTrack={{ type: "system" }}
+    />;
+
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "disabled", value: undefined }}
+      selectedTextTrack={{ type: "disabled", value: undefined }}
+    />;
+
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "title", value: "French 1" }}
+      selectedTextTrack={{ type: "title", value: "French 1" }}
+    />;
+
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "language", value: "fr" }}
+      selectedTextTrack={{ type: "language", value: "fr" }}
+    />;
+
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "index", value: 0 }}
+      selectedTextTrack={{ type: "index", value: 0 }}
+    />;
+  });
+
+  it("raises error when passed an unrecognized value key", () => {
+    // $FlowExpectedError
+    <Video
+      source={0}
+      selectedAudioTrack={{ type: "index", value: "notNumber" }}
+    />;
+
+    // $FlowExpectedError
+    <Video source={0} selectedTextTrack={{ type: "language", value: 69 }} />;
+
+    // $FlowExpectedError
+    <Video source={0} selectedTextTrack={{ type: "unsutortedType" }} />;
+
+    // $FlowExpectedError
+    <Video source={0} selectedAudioTrack={{ type: "title", value: 13 }} />;
+  });
+});
+
+describe("TextTrackType", () => {
+  it("must has values", () => {
+    (TextTrackType.SRT: "application/x-subrip");
+    (TextTrackType.TTML: "application/ttml+xml");
+    (TextTrackType.VTT: "text/vtt");
+  });
+});
+
+describe("public class methods", () => {
+  var video = new Video();
+
+  it("must create react element", () => {
+    (video: React.ElementRef<typeof Video>);
+  });
+
+  describe("seek", () => {
+    it("seek must call with number ", () => {
+      video.seek(1);
+
+      // $FlowExpectedError
+      video.seek();
+    });
+
+    it("must call seek with number and tolerance IOS argument", () => {
+      var toleranceIOS = 1;
+
+      video.seek(1, toleranceIOS);
+    });
+  });
+
+  describe("must call dismissFullscreenPlayer", () => {
+    video.dismissFullscreenPlayer();
+  });
+
+  describe("must call presentFullscreenPlayer", () => {
+    video.presentFullscreenPlayer();
+  });
+
+  describe("setNativeProps", () => {
+    it("must call with valid props", () => {
+      video.setNativeProps({ paused: true });
+
+      // $FlowExpectedError
+      video.setNativeProps({ foo: 'bar' });
+    });
+  });
+});
+
+describe("props", () => {
+  it("must render with source prop", () => {
+    <>
+      <Video source={0} />
+      <Video
+        source={{ uri: "http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4" }}
+      />
+    </>;
+  });
+
+  it("must throw error when source is void", () => {
+    // $FlowExpectedError
+    <Video source={null} />;
+
+    // $FlowExpectedError
+    <Video source={undefined} />;
+  });
+});
+
+it("must used with poster prop", () => {
+  <Video
+    source={0}
+    //
+    poster="https://example.com"
+  />;
+
+  <Video
+    source={0}
+    //
+    poster={undefined}
+  />;
+});
+
+it("must render with number props", () => {
+  <Video
+    source={0}
+    //
+
+    volume={1}
+    stereoPan={1}
+    rate={1}
+    currentTime={1}
+    progressUpdateInterval={1}
+    scaleX={1}
+    scaleY={1}
+    translateX={1}
+    translateY={1}
+    rotation={1}
+  />;
+
+  <Video
+    source={0}
+    //
+
+    volume={undefined}
+    stereoPan={undefined}
+    rate={undefined}
+    currentTime={undefined}
+    progressUpdateInterval={undefined}
+    scaleX={undefined}
+    scaleY={undefined}
+    translateX={undefined}
+    translateY={undefined}
+    rotation={undefined}
+  />;
+});
+
+describe("boolean props", () => {
+  it("must render with boolean props", () => {
+    <Video
+      source={0}
+      //
+      paused={false}
+      muted={false}
+      playInBackground={false}
+      playWhenInactive={false}
+      disableFocus={false}
+      controls={false}
+      audioOnly={false}
+      useTextureView={false}
+    />;
+
+    <Video
+      source={0}
+      //
+      paused
+      muted
+      playInBackground
+      playWhenInactive
+      disableFocus
+      controls
+      audioOnly
+      useTextureView
+    />;
+  });
+});
+
+describe("Fullscreen Event props", () => {
+  it("passes when used properly", () => {
+    <Video
+      source={0}
+      //
+      onFullscreenPlayerWillPresent={() => {}}
+      onFullscreenPlayerDidPresent={() => {}}
+      onFullscreenPlayerWillDismiss={() => {}}
+      onFullscreenPlayerDidDismiss={() => {}}
+    />;
+  });
+});
+
+it("must passes when used properly resizeMode", () => {
+  <>
+    <Video source={0} resizeMode="contain" />
+    <Video source={0} resizeMode="cover" />
+    <Video source={0} resizeMode="stretch" />
+    <Video source={0} resizeMode={undefined} />
+  </>;
+
+  // $FlowExpectedError
+  var b = <Video source={0} resizeMode="unSupportedType" />;
+});
+
+it("must passes when used properly posterResizeMode", () => {
+  <>
+    <Video source={0} posterResizeMode="contain" />
+    <Video source={0} posterResizeMode="cover" />
+    <Video source={0} posterResizeMode="stretch" />
+    <Video source={0} posterResizeMode="repeat" />
+    <Video source={0} posterResizeMode="center" />
+    <Video source={0} posterResizeMode={undefined} />
+  </>;
+
+  // $FlowExpectedError
+  <Video source={0} posterResizeMode="unSupportedType" />;
+});
+
+describe("events", () => {
+  describe("onTimedMetadata", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onTimedMetadata={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.metadata: $ReadOnlyArray<TimedMetadata>);
+        }}
+      />;
+      <Video source={0} onTimedMetadata={() => {}} />;
+      <Video source={0} onTimedMetadata={undefined} />;
+    });
+  });
+
+  describe("onAudioFocusChanged", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onAudioFocusChanged={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.hasAudioFocus: boolean);
+        }}
+      />;
+      <Video source={0} onAudioFocusChanged={() => {}} />;
+      <Video source={0} onAudioFocusChanged={undefined} />;
+    });
+  });
+
+  describe("onProgress", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onProgress={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.currentTime: number);
+          (event.playableDuration: number);
+          (event.seekableDuration: number);
+        }}
+      />;
+      <Video source={0} onProgress={() => {}} />;
+      <Video source={0} onProgress={undefined} />;
+    });
+  });
+
+  describe("onBuffer", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onBuffer={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.isBuffering: boolean);
+        }}
+      />;
+      <Video source={0} onBuffer={() => {}} />;
+      <Video source={0} onBuffer={undefined} />;
+    });
+  });
+
+  describe("onLoad", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onLoad={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.audioTracks: $ReadOnlyArray<TrackDescriptor>);
+          (event.canPlayFastForward: boolean);
+          (event.canPlayReverse: boolean);
+          (event.canPlaySlowForward: boolean);
+          (event.canPlaySlowReverse: boolean);
+          (event.canStepBackward: boolean);
+          (event.canStepForward: boolean);
+          (event.currentTime: number);
+          (event.duration: number);
+          (event.textTracks: $ReadOnlyArray<TrackDescriptor>);
+
+          // $FlowExpectedError - read-only object
+          event.naturalSize.abc = 123;
+
+          (event.naturalSize.height: number);
+          (event.naturalSize.orientation: string);
+          (event.naturalSize.width: number);
+        }}
+      />;
+      <Video source={0} onLoad={() => {}} />;
+      <Video source={0} onLoad={undefined} />;
+    });
+  });
+
+  describe("onLoadStart", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        onLoadStart={event => {
+          // $FlowExpectedError - read-only event
+          event.abc = 123;
+
+          (event.isNetwork: boolean);
+          (event.type: string);
+          (event.uri: string);
+        }}
+      />;
+      <Video source={0} onLoadStart={() => {}} />;
+      <Video source={0} onLoadStart={undefined} />;
+    });
+  });
+
+  describe("other events", () => {
+    it("must passes when used properly", () => {
+      <Video
+        source={0}
+        //
+        onError={() => {}}
+        onSeek={() => {}}
+        onEnd={() => {}}
+        onReadyForDisplay={() => {}}
+        onPlaybackStalled={() => {}}
+        onPlaybackResume={() => {}}
+        onPlaybackRateChange={() => {}}
+        onAudioBecomingNoisy={() => {}}
+      />;
+
+      <Video
+        source={0}
+        //
+        onError={undefined}
+        onSeek={undefined}
+        onEnd={undefined}
+        onReadyForDisplay={undefined}
+        onPlaybackStalled={undefined}
+        onPlaybackResume={undefined}
+        onPlaybackRateChange={undefined}
+        onAudioBecomingNoisy={undefined}
+      />;
+    });
+  });
+});
diff --git a/definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.104.x-/react-navigation-drawer_v2.x.x.js b/definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation-drawer_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.104.x-/react-navigation-drawer_v2.x.x.js
rename to definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation-drawer_v2.x.x.js
diff --git a/definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.201.x-/react-navigation-drawer_v2.x.x.js b/definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.201.x-/react-navigation-drawer_v2.x.x.js
new file mode 100644
index 0000000000..d616355194
--- /dev/null
+++ b/definitions/npm/react-navigation-drawer_v2.x.x/flow_v0.201.x-/react-navigation-drawer_v2.x.x.js
@@ -0,0 +1,686 @@
+// @flow
+
+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.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 1A
+   * 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;
+
+  /**
+   * SECTION 1B
+   * The following are type declarations for core types necessary for every
+   * React Navigation libdef.
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+    +toChildKey?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationJumpToAction = {|
+    +type: 'Navigation/JUMP_TO';
+    +preserveFocus: boolean,
+    +routeName: string,
+    +key?: string,
+    +params?: NavigationParams,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction
+    | NavigationJumpToAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<NavigationState>,
+  |};
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenProps = { [key: string]: mixed, ... };
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: ?NavigationScreenProps,
+    theme: SupportedThemes,
+  ) => 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 NavigationScreenOptions = { title?: string, ... };
+
+  declare export type SupportedThemes = 'light' | 'dark';
+
+  declare export type NavigationScreenConfigProps = $Shape<{|
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: NavigationScreenProps,
+    theme: SupportedThemes,
+  |}>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({|
+        ...NavigationScreenConfigProps,
+        navigationOptions: Options,
+      |}) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare type _NavigationRouteConfigCore = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    params?: NavigationParams,
+    path?: string,
+  |};
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | {| ..._NavigationRouteConfigCore, screen: NavigationComponent |}
+    | {| ..._NavigationRouteConfigCore, getScreen: () => NavigationComponent |};
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    goBack: (routeKey?: ?string) => boolean,
+    dismiss: () => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+            routeName: string,
+            params?: NavigationParams,
+            action?: NavigationNavigateAction,
+            key?: string,
+            ...
+          },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    theme?: SupportedThemes | 'no-preference',
+    detached?: boolean,
+    ...
+  }>;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationDescriptor
+   */
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    getComponent: () => NavigationComponent,
+    ...
+  };
+
+  declare export type NavigationDescriptorMap = {
+    [key: string]: NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: SHARED TYPE DEFINITIONS
+  // This section too is copy-pasted, but it's not identical across all React
+  // Navigation libdefs. We pick out bits and pieces that we need.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 2A
+   * We start with definitions we have copy-pasted, either from in-package
+   * types, other Flow libdefs, or from TypeScript types somewhere.
+   */
+
+  // This is copied from react-native-renimated's Typescript libdef
+  // https://github.com/kmagiera/react-native-reanimated/blob/master/react-native-reanimated.d.ts
+  declare class AnimatedNode<T> {
+    constructor(
+      nodeConfig: {...},
+      inputNodes?: $ReadOnlyArray<AnimatedNode<any>>,
+    ): void;
+    isNativelyInitialized(): boolean;
+  }
+
+  /**
+   * SECTION 2B
+   * This section usually contains exported types that are shared by some but
+   * not all react-navigation libdefs. However, react-navigation-drawer has no
+   * such types.
+   */
+
+  //---------------------------------------------------------------------------
+  // SECTION 3: UNIQUE TYPE DEFINITIONS
+  // This section contains exported types that are not present in any other
+  // React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * DrawerRouter
+   */
+
+  declare export type NavigationDrawerProp<+S> =
+    & NavigationScreenProp<S>
+    & {
+        jumpTo: (routeName: string, key?: string) => void,
+        openDrawer: () => boolean,
+        closeDrawer: () => boolean,
+        toggleDrawer: () => boolean,
+        ...
+      };
+
+  declare type _Scene = {|
+    route: NavigationRoute,
+    index: number,
+    focused: boolean,
+    tintColor?: string,
+  |};
+  declare type _ThemedColor =
+    | string
+    | {| light: string, dark: string |};
+  declare type _DrawerNavigatorItemsProps = {|
+    items: NavigationRoute[],
+    activeItemKey?: ?string,
+    activeTintColor?: _ThemedColor,
+    activeBackgroundColor?: _ThemedColor,
+    inactiveTintColor?: _ThemedColor,
+    inactiveBackgroundColor?: _ThemedColor,
+    getLabel: (scene: _Scene) => React$Node,
+    renderIcon: (scene: _Scene) => React$Node,
+    onItemPress: (scene: {|
+      route: NavigationRoute,
+      focused: boolean,
+    |}) => void,
+    itemsContainerStyle?: ViewStyleProp,
+    itemStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    activeLabelStyle?: TextStyleProp,
+    inactiveLabelStyle?: TextStyleProp,
+    iconContainerStyle?: ViewStyleProp,
+    drawerPosition: 'left' | 'right',
+  |};
+
+  declare type _NavigationDrawerState =
+    & NavigationState
+    & { isDrawerOpen: boolean, ... };
+  declare type _DrawerContentComponentProps = {|
+    ..._DrawerNavigatorItemsProps,
+    +navigation: NavigationDrawerProp<_NavigationDrawerState>,
+    descriptors: NavigationDescriptorMap,
+    drawerOpenProgress: AnimatedNode<number>,
+    screenProps: NavigationScreenProps,
+  |};
+
+  declare export type NavigationDrawerRouterConfig = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    unmountInactiveRoutes?: boolean,
+    resetOnBlur?: boolean,
+    initialRouteName?: string,
+    contentComponent?: React$ComponentType<_DrawerContentComponentProps>,
+    contentOptions?: {...},
+    backBehavior?: 'none' | 'initialRoute' | 'history',
+  |};
+
+  declare export type NavigationDrawerScreenOptions = {|
+    ...$Exact<NavigationScreenOptions>,
+    drawerIcon?:
+      | React$Node
+      | ((options: {| tintColor: ?string, focused: boolean |}) => ?React$Node),
+    drawerLabel?:
+      | React$Node
+      | ((options: {| tintColor: ?string, focused: boolean |}) => ?React$Node),
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+  |};
+
+  /**
+   * DrawerView
+   */
+
+  declare type _DrawerViewProps = {|
+    edgeWidth: number,
+    drawerWidth: number | (() => number),
+    drawerPosition: 'left' | 'right',
+    drawerType: 'front' | 'back' | 'slide',
+    statusBarAnimation: 'slide' | 'none' | 'fade',
+  |};
+  declare type _DrawerViewOptionalProps = {|
+    minSwipeDistance?: number,
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    keyboardDismissMode?: 'none' | 'on-drag',
+    hideStatusBar?: boolean,
+    drawerBackgroundColor?: _ThemedColor,
+    overlayColor?: _ThemedColor,
+    style?: ViewStyleProp,
+    sceneContainerStyle?: ViewStyleProp,
+    onDrawerClose?: () => void,
+    onDrawerOpen?: () => void,
+    gestureHandlerProps?: {...},
+  |};
+  declare type _DrawerViewConfig = {|
+    ...NavigationDrawerRouterConfig,
+    ..._DrawerViewProps,
+    ..._DrawerViewOptionalProps,
+  |};
+
+  declare type DrawerViewProps = {|
+    lazy: boolean,
+    navigation: NavigationDrawerProp<_NavigationDrawerState>,
+    descriptors: NavigationDescriptorMap,
+    navigationConfig: _DrawerViewConfig,
+    screenProps?: NavigationScreenProps,
+  |};
+
+  /**
+   * DrawerNavigator
+   */
+
+  declare type _Partial<T> = $Rest<T, {...}>;
+  declare export type DrawerNavigatorConfig = {|
+    ...NavigationDrawerRouterConfig,
+    ..._Partial<_DrawerViewProps>,
+    ..._DrawerViewOptionalProps,
+  |};
+
+  //---------------------------------------------------------------------------
+  // SECTION 4: EXPORTED MODULE
+  // This is the only section that types exports. Other sections export types,
+  // but this section types the module's exports.
+  //---------------------------------------------------------------------------
+
+  declare export function createDrawerNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: DrawerNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare export var DrawerActions: {|
+    OPEN_DRAWER: 'Navigation/OPEN_DRAWER',
+    CLOSE_DRAWER: 'Navigation/CLOSE_DRAWER',
+    TOGGLE_DRAWER: 'Navigation/TOGGLE_DRAWER',
+    DRAWER_OPENED: 'Navigation/DRAWER_OPENED',
+    DRAWER_CLOSED: 'Navigation/DRAWER_CLOSED',
+
+    openDrawer: (payload: {| key?: string |}) => NavigationOpenDrawerAction,
+    closeDrawer: (payload: {| key?: string |}) => NavigationCloseDrawerAction,
+    toggleDrawer: (payload: {| key?: string |}) => NavigationToggleDrawerAction,
+  |};
+
+  declare export function DrawerRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationDrawerRouterConfig
+  ): NavigationRouter<any, NavigationDrawerScreenOptions>;
+
+  declare type _DrawerScene = {|
+    route: NavigationRoute,
+    focused: boolean,
+    index: number,
+    tintColor?: string,
+  |};
+  declare type _DrawerItemsProps = {|
+    navigation: NavigationDrawerProp<_NavigationDrawerState>,
+    descriptors: NavigationDescriptorMap,
+    drawerOpenProgress: AnimatedNode<number>,
+    screenProps?: NavigationScreenProps,
+    items: NavigationRoute[],
+    activeItemKey?: ?string,
+    activeTintColor?: _ThemedColor,
+    activeBackgroundColor?: _ThemedColor,
+    inactiveTintColor?: _ThemedColor,
+    inactiveBackgroundColor?: _ThemedColor,
+    getLabel: (scene: _DrawerScene) => React$Node,
+    renderIcon: (scene: _DrawerScene) => React$Node,
+    onItemPress: (info: {|
+      route: NavigationRoute,
+      focused: boolean,
+    |}) => void,
+    itemsContainerStyle?: ViewStyleProp,
+    itemStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    activeLabelStyle?: TextStyleProp,
+    inactiveLabelStyle?: TextStyleProp,
+    iconContainerStyle?: ViewStyleProp,
+    drawerPosition: 'left' | 'right',
+  |};
+  declare export var DrawerNavigatorItems: React$ComponentType<_DrawerItemsProps>;
+
+  declare type _DrawerSidebarProps = {|
+    contentComponent?: React$ComponentType<_DrawerContentComponentProps>,
+    contentOptions?: {...},
+    screenProps?: NavigationScreenProps,
+    navigation: NavigationDrawerProp<_NavigationDrawerState>,
+    descriptors: NavigationDescriptorMap,
+    drawerOpenProgress: AnimatedNode<number>,
+    drawerPosition: 'left' | 'right',
+    style?: ViewStyleProp,
+  |};
+  declare export var DrawerSidebar: React$ComponentType<_DrawerSidebarProps>;
+
+  declare export var DrawerView: React$ComponentType<DrawerViewProps>;
+
+  declare export var DrawerGestureContext: React$Context<?React$Ref<any>>;
+
+}
diff --git a/definitions/npm/react-navigation-stack_v1.x.x/flow_v0.104.x-/react-navigation-stack_v1.x.x.js b/definitions/npm/react-navigation-stack_v1.x.x/flow_v0.104.x-v0.200.x/react-navigation-stack_v1.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation-stack_v1.x.x/flow_v0.104.x-/react-navigation-stack_v1.x.x.js
rename to definitions/npm/react-navigation-stack_v1.x.x/flow_v0.104.x-v0.200.x/react-navigation-stack_v1.x.x.js
diff --git a/definitions/npm/react-navigation-stack_v1.x.x/flow_v0.201.x-/react-navigation-stack_v1.x.x.js b/definitions/npm/react-navigation-stack_v1.x.x/flow_v0.201.x-/react-navigation-stack_v1.x.x.js
new file mode 100644
index 0000000000..7ba2acd890
--- /dev/null
+++ b/definitions/npm/react-navigation-stack_v1.x.x/flow_v0.201.x-/react-navigation-stack_v1.x.x.js
@@ -0,0 +1,949 @@
+// @flow
+
+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.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 1A
+   * 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;
+
+  /**
+   * SECTION 1B
+   * The following are type declarations for core types necessary for every
+   * React Navigation libdef.
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+    +toChildKey?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationJumpToAction = {|
+    +type: 'Navigation/JUMP_TO';
+    +preserveFocus: boolean,
+    +routeName: string,
+    +key?: string,
+    +params?: NavigationParams,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction
+    | NavigationJumpToAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<NavigationState>,
+  |};
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenProps = { [key: string]: mixed, ... };
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: ?NavigationScreenProps,
+    theme: SupportedThemes,
+  ) => 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 NavigationScreenOptions = { title?: string, ... };
+
+  declare export type SupportedThemes = 'light' | 'dark';
+
+  declare export type NavigationScreenConfigProps = $Shape<{|
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: NavigationScreenProps,
+    theme: SupportedThemes,
+  |}>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({|
+        ...NavigationScreenConfigProps,
+        navigationOptions: Options,
+      |}) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare type _NavigationRouteConfigCore = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    params?: NavigationParams,
+    path?: string,
+  |};
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | {| ..._NavigationRouteConfigCore, screen: NavigationComponent |}
+    | {| ..._NavigationRouteConfigCore, getScreen: () => NavigationComponent |};
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    goBack: (routeKey?: ?string) => boolean,
+    dismiss: () => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+            routeName: string,
+            params?: NavigationParams,
+            action?: NavigationNavigateAction,
+            key?: string,
+            ...
+          },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    theme?: SupportedThemes | 'no-preference',
+    detached?: boolean,
+    ...
+  }>;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationDescriptor
+   */
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    getComponent: () => NavigationComponent,
+    ...
+  };
+
+  declare export type NavigationDescriptorMap = {
+    [key: string]: NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: SHARED TYPE DEFINITIONS
+  // This section too is copy-pasted, but it's not identical across all React
+  // Navigation libdefs. We pick out bits and pieces that we need.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 2A
+   * We start with definitions we have copy-pasted, either from in-package
+   * types, other Flow libdefs, or from TypeScript types somewhere.
+   */
+
+  // This is 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 class AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // This is copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare class Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare class AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare class 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;
+  }
+
+  /**
+   * SECTION 2B
+   * The following are the actually useful definitions in Section 2, that are
+   * used below in section 3, but also in other libdefs.
+   */
+
+  declare export type NavigationPathsConfig = { [routeName: string]: string, ... };
+
+  /**
+   * SafeAreaView
+   */
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewInsets = $Shape<{|
+    top: _SafeAreaViewForceInsetValue,
+    bottom: _SafeAreaViewForceInsetValue,
+    left: _SafeAreaViewForceInsetValue,
+    right: _SafeAreaViewForceInsetValue,
+    vertical: _SafeAreaViewForceInsetValue,
+    horizontal: _SafeAreaViewForceInsetValue,
+  |}>;
+
+  /**
+   * Interpolation
+   */
+
+  declare export type NavigationStackInterpolatorProps = $Shape<{|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode?: HeaderMode,
+    shadowEnabled?: boolean,
+    cardOverlayEnabled?: boolean,
+  |}>;
+
+  declare type _InterpolationResult = { [key: string]: mixed, ... };
+  declare export type NavigationStackInterpolator =
+    (props: NavigationStackInterpolatorProps) => _InterpolationResult;
+
+  /**
+   * Header
+   */
+
+  declare export type HeaderMode = 'float' | 'screen' | 'none';
+
+  declare export type HeaderProps = {|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode: HeaderMode,
+    leftInterpolator?: NavigationStackInterpolator,
+    titleInterpolator?: NavigationStackInterpolator,
+    rightInterpolator?: NavigationStackInterpolator,
+    backgroundInterpolator?: NavigationStackInterpolator,
+    layoutPreset: 'left' | 'center',
+    transitionPreset?: 'fade-in-place' | 'uikit',
+    backTitleVisible?: boolean,
+    isLandscape: boolean,
+  |};
+
+  /**
+   * StackRouter
+   */
+
+  declare export type NavigationStackProp<+S> =
+    & NavigationScreenProp<S>
+    & {
+        pop: (n?: number, params?: {| immediate?: boolean |}) => boolean,
+        popToTop: (params?: {| immediate?: boolean |}) => boolean,
+        push: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        replace: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        reset: (actions: NavigationAction[], index: number) => boolean,
+        ...
+      };
+
+  declare type _HeaderBackButtonProps = {|
+    disabled?: boolean,
+    onPress: () => void,
+    pressColorAndroid?: string,
+    tintColor?: ?string,
+    backImage?: React$ComponentType<{
+      tintColor: string,
+      title?: ?string,
+      ...
+    }>,
+    title?: ?string,
+    truncatedTitle?: ?string,
+    backTitleVisible?: boolean,
+    allowFontScaling?: boolean,
+    titleStyle?: ?TextStyleProp,
+    width?: ?number,
+  |};
+
+  declare export type NavigationStackScreenOptions = NavigationScreenOptions & {
+    header?: ?(React$Node | (HeaderProps => React$Node)),
+    headerTransparent?: boolean,
+    headerTitle?: (props: { children: ?string, ... }) => React$Node | React$Node,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: ((props: _HeaderBackButtonProps) => React$Node) | React$Node,
+    headerBackTitle?: ?string,
+    headerBackImage?: (props: {|
+      tintColor?: string,
+      title?: ?string,
+    |}) => React$Node,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: React$Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: _SafeAreaViewInsets,
+    headerBackground?: React$Node | React$ElementType,
+    gesturesEnabled?: boolean,
+    gestureResponseDistance?: {|
+      vertical?: number,
+      horizontal?: number,
+    |},
+    gestureDirection?: 'default' | 'inverted',
+    ...
+  };
+
+  declare export type NavigationStackRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    initialRouteKey?: string,
+  |};
+
+  /**
+   * Stack Gestures, Animations, and Interpolators
+   */
+
+  declare export type NavigationStackLayout = {
+    height: AnimatedValue,
+    initHeight: number,
+    initWidth: number,
+    isMeasured: boolean,
+    width: AnimatedValue,
+    ...
+  };
+
+  declare export type NavigationStackScene = {
+    index: number,
+    isActive: boolean,
+    isStale: boolean,
+    key: string,
+    route: NavigationRoute,
+    descriptor: ?NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 3: UNIQUE TYPE DEFINITIONS
+  // This section contains exported types that are not present in any other
+  // React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * NavigationStackTransitionProps
+   */
+
+  declare export type NavigationStackTransitionProps = $Shape<{|
+    // The layout of the screen container
+    layout: NavigationStackLayout,
+    // The destination navigation state of the transition
+    navigation: NavigationStackProp<NavigationState>,
+    // The progressive index of the transitioner's navigation state.
+    position: AnimatedValue,
+    // All the scenes of the transitioner.
+    scenes: Array<NavigationStackScene>,
+    // 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: NavigationStackScene,
+    index: number,
+  |}>;
+
+
+  /**
+   * StackNavigator
+   */
+
+  declare type _NavigationTransitionConfigurer = (
+    transitionProps: NavigationStackTransitionProps,
+    prevTransitionProps: ?NavigationStackTransitionProps,
+    isModal: boolean
+  ) => TransitionConfig;
+
+  declare export type NavigationStackViewConfig = {|
+    mode?: 'card' | 'modal',
+    headerMode?: HeaderMode,
+    headerLayoutPreset?: 'left' | 'center',
+    headerTransitionPreset?: 'fade-in-place' | 'uikit',
+    headerBackgroundTransitionPreset?: 'translate' | 'fade' | 'toggle',
+    headerBackTitleVisible?: boolean,
+    disableKeyboardHandling?: boolean,
+    cardShadowEnabled?: boolean,
+    cardOverlayEnabled?: boolean,
+    onTransitionStart?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps,
+    ) => void,
+    onTransitionEnd?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps,
+    ) => void,
+    cardStyle?: ViewStyleProp,
+    transitionConfig?: _NavigationTransitionConfigurer,
+    transparentCard?: boolean,
+  |};
+
+  declare export type StackNavigatorConfig = $Shape<{|
+    ...NavigationStackViewConfig,
+    ...NavigationStackRouterConfig,
+  |}>;
+
+  /**
+   * Transitioner
+   */
+
+  declare export type NavigationTransitionSpec = {
+    // A timing function such as `Animated.timing`.
+    timing: (value: AnimatedValue, config: any) => any,
+    duration?: number,
+    // An easing function from `Easing`.
+    easing?: (t: number) => number,
+    ...
+  };
+
+  // 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: NavigationStackInterpolator,
+    // How to animate position and opacity of the header components
+    // based on the value generated by the transitionSpec
+    headerLeftInterpolator?: NavigationStackInterpolator,
+    headerLeftLabelInterpolator?: NavigationStackInterpolator,
+    headerLeftButtonInterpolator?: NavigationStackInterpolator,
+    headerTitleFromLeftInterpolator?: NavigationStackInterpolator,
+    headerTitleInterpolator?: NavigationStackInterpolator,
+    headerRightInterpolator?: NavigationStackInterpolator,
+    headerBackgroundInterpolator?: NavigationStackInterpolator,
+    headerLayoutInterpolator?: NavigationStackInterpolator,
+    // The style of the container. Useful when a scene doesn't have
+    // 100% opacity and the underlying container is visible.
+    containerStyle?: ViewStyleProp,
+    containerStyleLight?: ViewStyleProp,
+    containerStyleDark?: ViewStyleProp,
+  |};
+
+  //---------------------------------------------------------------------------
+  // SECTION 4: EXPORTED MODULE
+  // This is the only section that types exports. Other sections export types,
+  // but this section types the module's exports.
+  //---------------------------------------------------------------------------
+
+  declare export function createStackNavigator(
+    routeConfigMap: NavigationRouteConfigMap,
+    stackConfig?: StackNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare export var Header: React$ComponentType<HeaderProps> & { HEIGHT: number, ... };
+
+  declare export var HeaderBackButton: React$ComponentType<
+    _HeaderBackButtonProps
+  >;
+
+  declare type _HeaderTitleProps = {|
+    children: React$Node,
+    style?: AnimatedTextStyleProp,
+  |};
+  declare export var HeaderTitle: React$ComponentType<_HeaderTitleProps>;
+
+  declare export var HeaderStyleInterpolator: {|
+    forLayout: NavigationStackInterpolator,
+    forLeft: NavigationStackInterpolator,
+    forLeftButton: NavigationStackInterpolator,
+    forLeftLabel: NavigationStackInterpolator,
+    forCenterFromLeft: NavigationStackInterpolator,
+    forCenter: NavigationStackInterpolator,
+    forRight: NavigationStackInterpolator,
+    forBackground: NavigationStackInterpolator,
+    forBackgroundWithInactiveHidden: NavigationStackInterpolator,
+    forBackgroundWithFade: NavigationStackInterpolator,
+    forBackgroundWithTranslation: NavigationStackInterpolator,
+  |};
+
+  declare type _StackViewProps = {|
+    navigation: NavigationStackProp<NavigationState>,
+    descriptors: NavigationDescriptorMap,
+    navigationConfig: NavigationStackViewConfig,
+    onTransitionStart?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps
+    ) => void,
+    onGestureBegin?: () => void,
+    onGestureCanceled?: () => void,
+    onGestureEnd?: () => void,
+    screenProps?: NavigationScreenProps,
+  |};
+  declare export var StackView: React$ComponentType<_StackViewProps>;
+
+  declare type _StackViewCardProps = {|
+    ...$Exact<_PointerEventsInputProps>,
+    style: ViewStyleProp,
+    animatedStyle: any,
+    position: AnimatedInterpolation,
+    transparent?: boolean,
+    children: React$Node,
+  |};
+  declare export var StackViewCard: React$ComponentType<_StackViewCardProps>;
+
+  declare type _StackViewLayoutProps = {|
+    mode?: 'card' | 'modal',
+    headerMode?: HeaderMode,
+    headerLayoutPreset?: 'left' | 'center',
+    headerTransitionPreset?: 'fade-in-place' | 'uikit',
+    headerBackgroundTransitionPreset?: 'translate' | 'fade' | 'toggle',
+    headerBackTitleVisible?: boolean,
+    shadowEnabled?: boolean,
+    cardStyle?: ViewStyleProp,
+    transitionConfig?: _NavigationTransitionConfigurer,
+    transparentCard?: boolean,
+    transitionProps: NavigationStackTransitionProps,
+    lastTransitionProps: ?NavigationStackTransitionProps,
+    onGestureBegin?: () => void,
+    onGestureEnd?: () => void,
+    onGestureCanceled?: () => void,
+    screenProps?: NavigationScreenProps,
+  |};
+  declare export var StackViewLayout: React$ComponentType<_StackViewLayoutProps>;
+
+  declare export var StackViewStyleInterpolator: {|
+    forHorizontal: NavigationStackInterpolator,
+    forVertical: NavigationStackInterpolator,
+    forFadeFromBottomAndroid: NavigationStackInterpolator,
+    forFadeToBottomAndroid: NavigationStackInterpolator,
+    forFade: NavigationStackInterpolator,
+    forNoAnimation: NavigationStackInterpolator,
+  |};
+
+  declare export var StackViewTransitionConfigs: {|
+    defaultTransitionConfig: _NavigationTransitionConfigurer,
+    getTransitionConfig: (
+      transitionConfigurer: ?_NavigationTransitionConfigurer,
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps,
+      isModal: boolean
+    ) => TransitionConfig,
+    SlideFromRightIOS: TransitionConfig,
+    ModalSlideFromBottomIOS: TransitionConfig,
+    FadeInFromBottomAndroid: TransitionConfig,
+    FadeOutToBottomAndroid: TransitionConfig,
+    NoAnimation: TransitionConfig,
+  |};
+
+  declare type _PointerEventsInputProps = {
+    scene: NavigationStackScene,
+    navigation: NavigationStackProp<NavigationState>,
+    realPosition: AnimatedValue,
+    ...
+  };
+  declare type _PointerEventsInjectedProps = {
+    pointerEvents: 'box-only' | 'none' | 'auto',
+    onComponentRef: (ref: any) => void,
+    ...
+  };
+  declare export function createPointerEventsContainer<
+    Props: _PointerEventsInputProps & _PointerEventsInjectedProps,
+    ComponentType: React$ComponentType<Props>,
+  >(
+    Component: ComponentType
+  ): React$ComponentType<$Diff<React$ElementConfig<ComponentType>, _PointerEventsInjectedProps>>;
+
+  declare type _TransitionerProps = {|
+    render: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps
+    ) => React$Node,
+    configureTransition?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps
+    ) => NavigationTransitionSpec,
+    onTransitionStart?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps
+    ) => void,
+    onTransitionEnd?: (
+      transitionProps: NavigationStackTransitionProps,
+      prevTransitionProps: ?NavigationStackTransitionProps
+    ) => void,
+    navigation: NavigationStackProp<NavigationState>,
+    descriptors: NavigationDescriptorMap,
+    screenProps?: NavigationScreenProps,
+  |};
+  declare export var Transitioner: React$ComponentType<_TransitionerProps>;
+
+  declare export function ScenesReducer(
+    scenes: $ReadOnlyArray<NavigationStackScene>,
+    nextState: NavigationState,
+    prevState: ?NavigationState,
+    descriptors: NavigationDescriptorMap
+  ): NavigationStackScene[];
+
+  declare export var StackGestureContext: React$Context<?React$Ref<any>>;
+
+}
diff --git a/definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.104.x-/react-navigation-tabs_v2.x.x.js b/definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation-tabs_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.104.x-/react-navigation-tabs_v2.x.x.js
rename to definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation-tabs_v2.x.x.js
diff --git a/definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.201.x-/react-navigation-tabs_v2.x.x.js b/definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.201.x-/react-navigation-tabs_v2.x.x.js
new file mode 100644
index 0000000000..f3381ec546
--- /dev/null
+++ b/definitions/npm/react-navigation-tabs_v2.x.x/flow_v0.201.x-/react-navigation-tabs_v2.x.x.js
@@ -0,0 +1,779 @@
+// @flow
+
+declare module 'react-navigation-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.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 1A
+   * 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;
+
+  /**
+   * SECTION 1B
+   * The following are type declarations for core types necessary for every
+   * React Navigation libdef.
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+    +toChildKey?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationJumpToAction = {|
+    +type: 'Navigation/JUMP_TO';
+    +preserveFocus: boolean,
+    +routeName: string,
+    +key?: string,
+    +params?: NavigationParams,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction
+    | NavigationJumpToAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<NavigationState>,
+  |};
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenProps = { [key: string]: mixed, ... };
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: ?NavigationScreenProps,
+    theme: SupportedThemes,
+  ) => 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 NavigationScreenOptions = { title?: string, ... };
+
+  declare export type SupportedThemes = 'light' | 'dark';
+
+  declare export type NavigationScreenConfigProps = $Shape<{|
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: NavigationScreenProps,
+    theme: SupportedThemes,
+  |}>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({|
+        ...NavigationScreenConfigProps,
+        navigationOptions: Options,
+      |}) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare type _NavigationRouteConfigCore = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    params?: NavigationParams,
+    path?: string,
+  |};
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | {| ..._NavigationRouteConfigCore, screen: NavigationComponent |}
+    | {| ..._NavigationRouteConfigCore, getScreen: () => NavigationComponent |};
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    goBack: (routeKey?: ?string) => boolean,
+    dismiss: () => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+            routeName: string,
+            params?: NavigationParams,
+            action?: NavigationNavigateAction,
+            key?: string,
+            ...
+          },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    theme?: SupportedThemes | 'no-preference',
+    detached?: boolean,
+    ...
+  }>;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationDescriptor
+   */
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    getComponent: () => NavigationComponent,
+    ...
+  };
+
+  declare export type NavigationDescriptorMap = {
+    [key: string]: NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: SHARED TYPE DEFINITIONS
+  // This section too is copy-pasted, but it's not identical across all React
+  // Navigation libdefs. We pick out bits and pieces that we need.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 2A
+   * We start with definitions we have copy-pasted, either from in-package
+   * types, other Flow libdefs, or from TypeScript types somewhere.
+   */
+
+  // This is copied from react-native-renimated's Typescript libdef
+  // https://github.com/kmagiera/react-native-reanimated/blob/master/react-native-reanimated.d.ts
+  declare class AnimatedNode<T> {
+    constructor(
+      nodeConfig: {...},
+      inputNodes?: $ReadOnlyArray<AnimatedNode<any>>,
+    ): void;
+    isNativelyInitialized(): boolean;
+  }
+
+  // This is 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 AccessibilityState = {
+    disabled?: boolean,
+    selected?: boolean,
+    checked?: ?boolean | 'mixed',
+    busy?: boolean,
+    expanded?: boolean,
+    ...
+  };
+
+  /**
+   * SECTION 2B
+   * The following are the actually useful definitions in Section 2, that are
+   * used below in section 3, but also in other libdefs.
+   */
+
+  declare export type NavigationPathsConfig = { [routeName: string]: string, ... };
+
+  /**
+   * SafeAreaView
+   */
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewInsets = $Shape<{|
+    top: _SafeAreaViewForceInsetValue,
+    bottom: _SafeAreaViewForceInsetValue,
+    left: _SafeAreaViewForceInsetValue,
+    right: _SafeAreaViewForceInsetValue,
+    vertical: _SafeAreaViewForceInsetValue,
+    horizontal: _SafeAreaViewForceInsetValue,
+  |}>;
+
+  /**
+   * SwitchRouter
+   */
+
+  declare export type NavigationSwitchRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    // todo: type these as the real route names rather than 'string'
+    order?: string[],
+    // Does the back button cause the router to switch to the initial tab
+    backBehavior?: 'none' | 'initialRoute' | 'history' | 'order', // defaults `initialRoute`
+    resetOnBlur?: boolean,
+  |};
+
+  /**
+   * TabRouter
+   */
+
+  declare export type NavigationTabProp<+S> =
+    & NavigationScreenProp<S>
+    & { jumpTo: (routeName: string, key?: string) => void, ... };
+
+  declare export type NavigationTabRouterConfig = NavigationSwitchRouterConfig;
+
+  declare export type NavigationTabScreenOptions = {
+    ...$Exact<NavigationScreenOptions>,
+    tabBarLabel?: React$Node,
+    tabBarVisible?: boolean,
+    tabBarAccessibilityLabel?: string,
+    tabBarTestID?: string,
+    tabBarIcon?:
+      | React$Node
+      | ((props: {|
+          focused: boolean,
+          tintColor?: string,
+          horizontal?: boolean,
+        |}) => React$Node),
+    tabBarOnPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    tabBarOnLongPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 3: UNIQUE TYPE DEFINITIONS
+  // This section contains exported types that are not present in any other
+  // React Navigation libdef.
+  //---------------------------------------------------------------------------
+
+  /**
+   * TabNavigator
+   */
+
+  declare type _TabViewLayout = $Shape<{| height: number, width: number |}>;
+
+  declare export type TabNavigatorConfig<CustomProps: {...}> = {|
+    ...NavigationTabRouterConfig,
+    ...$Exact<CustomProps>,
+    tabBarComponent?: React$ElementType,
+    lazy?: boolean,
+  |};
+
+  declare type _MaterialTopTabBarOptions = {|
+    activeTintColor?: string,
+    allowFontScaling?: boolean,
+    bounces?: boolean,
+    inactiveTintColor?: string,
+    pressColor?: string,
+    pressOpacity?: number,
+    scrollEnabled?: boolean,
+    showIcon?: boolean,
+    showLabel?: boolean,
+    upperCaseLabel?: boolean,
+    tabStyle?: ViewStyleProp,
+    indicatorStyle?: ViewStyleProp,
+    iconStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    contentContainerStyle?: ViewStyleProp,
+    style?: ViewStyleProp,
+  |};
+  declare export type MaterialTopTabNavigatorConfig = TabNavigatorConfig<{|
+    tabBarOptions?: _MaterialTopTabBarOptions,
+    keyboardDismissMode?: 'none' | 'on-drag',
+    swipeEnabled?: boolean,
+    swipeDistanceThreshold?: number,
+    swipeVelocityThreshold?: number,
+    initialLayout?: _TabViewLayout,
+    lazyPlaceholderComponent?: React$ComponentType<{ route: {|
+      key: string,
+      routeName: string,
+    |}, ... }>,
+    tabBarPosition?: 'top' | 'bottom',
+    sceneContainerStyle?: ViewStyleProp,
+    style?: ViewStyleProp,
+  |}>;
+
+  declare type _ThemedColor =
+    | string
+    | {| light: string, dark: string |};
+  declare type _LabelPosition = 'beside-icon' | 'below-icon';
+  declare type _Orientation = 'horizontal' | 'vertical';
+  declare type _BottomTabBarOptions = {|
+    keyboardHidesTabBar?: boolean,
+    activeTintColor?: _ThemedColor,
+    inactiveTintColor?: _ThemedColor,
+    activeBackgroundColor?: _ThemedColor,
+    inactiveBackgroundColor?: _ThemedColor,
+    allowFontScaling?: boolean,
+    showLabel?: boolean,
+    showIcon?: boolean,
+    labelStyle?: TextStyleProp,
+    tabStyle?: ViewStyleProp,
+    labelPosition?:
+      | _LabelPosition
+      | ((options: {| deviceOrientation: _Orientation |}) => _LabelPosition),
+    adaptive?: boolean,
+    safeAreaInset?: _SafeAreaViewInsets,
+    style?: ViewStyleProp,
+  |};
+  declare export type BottomTabNavigatorConfig = TabNavigatorConfig<{| tabBarOptions?: _BottomTabBarOptions |}>;
+
+  /**
+   * Tab views
+   */
+
+  declare export type TabScene = {
+    route: NavigationRoute,
+    focused: boolean,
+    index: number,
+    tintColor?: ?string,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 4: EXPORTED MODULE
+  // This is the only section that types exports. Other sections export types,
+  // but this section types the module's exports.
+  //---------------------------------------------------------------------------
+
+  declare export function createBottomTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: BottomTabNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+  declare export function createMaterialTopTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: MaterialTopTabNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare type _SharedTabBarProps = {|
+    getAccessibilityLabel: (props: {| route: NavigationRoute |}) => ?string,
+    getTestID: (props: {| route: NavigationRoute |}) => ?string,
+    renderIcon: (props: {|
+      route: NavigationRoute,
+      focused: boolean,
+      tintColor?: string,
+      horizontal?: boolean,
+    |}) => React$Node,
+  |};
+
+  declare type _BottomTabBarButtonComponentProps = {
+    route: NavigationRoute,
+    focused: boolean,
+    onPress: () => void,
+    onLongPress: () => void,
+    testID?: string,
+    accessibilityLabel?: string,
+    accessibilityRole?: AccessibilityRole,
+    accessibilityStates?: AccessibilityState[],
+    style?: ViewStyleProp,
+    ...
+  };
+  declare type _BottomTabBarProps = {|
+    ..._BottomTabBarOptions,
+    ..._SharedTabBarProps,
+    navigation: NavigationTabProp<NavigationState>,
+    onTabPress: (props: {| route: NavigationRoute |}) => void,
+    onTabLongPress: (props: {| route: NavigationRoute |}) => void,
+    getAccessibilityRole: (props: {| route: NavigationRoute |}) => ?AccessibilityRole,
+    getAccessibilityStates: (props: {|
+      route: NavigationRoute,
+      focused: boolean,
+    |}) => AccessibilityState[],
+    getButtonComponent: (props: {| route: NavigationRoute |}) => ?React$ComponentType<_BottomTabBarButtonComponentProps>,
+    getLabelText: (props: {| route: NavigationRoute |}) =>
+      | ((scene: {|
+          focused: boolean,
+          tintColor?: string,
+          orientation?: 'horizontal' | 'vertical',
+        |}) => ?string)
+      | ?string,
+    isLandscape: boolean,
+    jumpTo: (key: string) => void,
+    screenProps: NavigationScreenProps,
+  |};
+  declare export var BottomTabBar: React$ComponentType<_BottomTabBarProps>;
+
+  declare type _MaterialTopTabBarProps = {|
+    ..._MaterialTopTabBarOptions,
+    ..._SharedTabBarProps,
+    layout: _TabViewLayout,
+    position: AnimatedNode<number>,
+    jumpTo: (key: string) => void,
+    getLabelText: (scene: {| route: NavigationRoute |}) =>
+      | ((scene: {|
+          focused: boolean,
+          tintColor: string,
+        |}) => ?string)
+      | ?string,
+    getAccessible?: (scene: {| route: NavigationRoute |}) => ?boolean,
+    renderBadge?: (scene: {| route: NavigationRoute |}) => React$Node,
+    onTabPress?: (scene: {| route: NavigationRoute |}) => void,
+    onTabLongPress?: (scene: {| route: NavigationRoute |}) => void,
+    tabBarPosition?: 'top' | 'bottom',
+    screenProps: NavigationScreenProps,
+    navigation: NavigationTabProp<NavigationState>,
+  |};
+  declare export var MaterialTopTabBar: React$ComponentType<
+    _MaterialTopTabBarProps
+  >;
+
+  declare type _TabViewProps = {
+    ..._SharedTabBarProps,
+    getLabelText: (props: {| route: NavigationRoute |}) => ?string,
+    renderScene: (props: {| route: NavigationRoute |}) => React$Node,
+    onIndexChange: (index: number) => void,
+    onTabPress: (props: {| route: NavigationRoute |}) => void,
+    onTabLongPress: (props: {| route: NavigationRoute |}) => void,
+    navigation: NavigationTabProp<NavigationState>,
+    descriptors: NavigationDescriptorMap,
+    screenProps?: NavigationScreenProps,
+    ...
+  };
+  declare export function createTabNavigator<
+    CustomProps: {...},
+  >(
+    TabView: React$ComponentType<_TabViewProps & CustomProps>
+  ): (
+    routeConfigMap: NavigationRouteConfigMap,
+    tabConfig?: TabNavigatorConfig<CustomProps>
+  ) => NavigationNavigator<any, any, any>;
+
+}
diff --git a/definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-/react-navigation_v2.x.x.js b/definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation_v2.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-/react-navigation_v2.x.x.js
rename to definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-v0.200.x/react-navigation_v2.x.x.js
diff --git a/definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-/test_react-navigation.js b/definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-v0.200.x/test_react-navigation.js
similarity index 100%
rename from definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-/test_react-navigation.js
rename to definitions/npm/react-navigation_v2.x.x/flow_v0.104.x-v0.200.x/test_react-navigation.js
diff --git a/definitions/npm/react-navigation_v2.x.x/flow_v0.201.x-/react-navigation_v2.x.x.js b/definitions/npm/react-navigation_v2.x.x/flow_v0.201.x-/react-navigation_v2.x.x.js
new file mode 100644
index 0000000000..b6a497936e
--- /dev/null
+++ b/definitions/npm/react-navigation_v2.x.x/flow_v0.201.x-/react-navigation_v2.x.x.js
@@ -0,0 +1,1272 @@
+// @flow
+
+declare module 'react-navigation' {
+  /**
+   * 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 NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction;
+
+  /**
+   * 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,
+    ...$Exact<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<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: {...}
+  > = React$ComponentType<{
+    ...Props,
+    ...NavigationNavigatorProps<Options, Route>,
+    ...
+  }> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: {...}
+  > = React$ComponentType<{
+    ...Props,
+    ...NavigationNavigatorProps<Options, State>,
+    ...
+  }> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<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?: ?(React$Node | (HeaderProps => React$Node)),
+    headerTransparent?: boolean,
+    headerTitle?: string | React$Node | React$ElementType,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: React$Node | React$ElementType,
+    headerBackTitle?: ?string,
+    headerBackImage?: React$Node | React$ElementType,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: React$Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: HeaderForceInset,
+    headerBackground?: React$Node | React$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',
+    headerLayoutPreset?: 'left' | 'center',
+    headerBackTitleVisible?: boolean,
+    cardStyle?: ViewStyleProp,
+    transitionConfig?: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps,
+      isModal: boolean
+    ) => TransitionConfig,
+    onTransitionStart?: () => void,
+    onTransitionEnd?: () => void,
+    transparentCard?: boolean,
+    disableKeyboardHandling?: boolean,
+  |};
+
+  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?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    tabBarLabel?:
+      | string
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    tabBarVisible?: boolean,
+    tabBarTestIDProps?: {
+      testID?: string,
+      accessibilityLabel?: string,
+      ...
+    },
+    tabBarOnPress?: ({
+      navigation: NavigationScreenProp<NavigationRoute>,
+      defaultHandler: () => void,
+      ...
+    }) => void,
+  |};
+
+  /**
+   * Drawer
+   */
+
+  declare export type NavigationDrawerScreenOptions = {|
+    ...$Exact<NavigationScreenOptions>,
+    drawerIcon?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    drawerLabel?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {| [ParamName]: void |} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {| [ParamName]: void |} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => NavigationScreenProp<any>,
+    isFocused: () => boolean,
+    // Shared action creators that exist for all routers
+    goBack: (routeKey?: ?string) => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+        routeName: string,
+        params?: NavigationParams,
+        action?: NavigationNavigateAction,
+        key?: string,
+        ...
+      },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    // StackRouter action creators
+    pop?: (n?: number, params?: { immediate?: boolean, ... }) => boolean,
+    popToTop?: (params?: { immediate?: boolean, ... }) => boolean,
+    push?: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    replace?: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    reset?: (actions: NavigationAction[], index: number) => boolean,
+    dismiss?: () => boolean,
+    // DrawerRouter action creators
+    openDrawer?: () => boolean,
+    closeDrawer?: () => boolean,
+    toggleDrawer?: () => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: {...},
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationEvents component
+   */
+
+  declare type _NavigationEventsProps = {
+    navigation?: NavigationScreenProp<NavigationState>,
+    onWillFocus?: NavigationEventCallback,
+    onDidFocus?: NavigationEventCallback,
+    onWillBlur?: NavigationEventCallback,
+    onDidBlur?: NavigationEventCallback,
+    ...
+  };
+  declare export var NavigationEvents: React$ComponentType<
+    _NavigationEventsProps
+  >;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: {...}
+  > = React$StatelessFunctionalComponent<{
+    ...Props,
+    ...NavigationContainerProps<State, Options>,
+    ...
+  }> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    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 = () => React$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 var NavigationActions: {
+    BACK: 'Navigation/BACK',
+    INIT: 'Navigation/INIT',
+    NAVIGATE: 'Navigation/NAVIGATE',
+    SET_PARAMS: 'Navigation/SET_PARAMS',
+    back: (payload?: { key?: ?string, ... }) => NavigationBackAction,
+    init: (payload?: { params?: NavigationParams, ... }) => NavigationInitAction,
+    navigate: (payload: {
+      routeName: string,
+      params?: ?NavigationParams,
+      action?: ?NavigationNavigateAction,
+      key?: string,
+      ...
+    }) => NavigationNavigateAction,
+    setParams: (payload: {
+      key: string,
+      params: NavigationParams,
+      ...
+    }) => NavigationSetParamsAction,
+    ...
+  };
+
+  declare export var StackActions: {
+    POP: 'Navigation/POP',
+    POP_TO_TOP: 'Navigation/POP_TO_TOP',
+    PUSH: 'Navigation/PUSH',
+    RESET: 'Navigation/RESET',
+    REPLACE: 'Navigation/REPLACE',
+    COMPLETE_TRANSITION: 'Navigation/COMPLETE_TRANSITION',
+    pop: (payload: {
+      n?: number,
+      immediate?: boolean,
+      ...
+    }) => NavigationPopAction,
+    popToTop: (payload: {
+      immediate?: boolean,
+      key?: string,
+      ...
+    }) => NavigationPopToTopAction,
+    push: (payload: {
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      key?: string,
+      ...
+    }) => NavigationPushAction,
+    reset: (payload: {
+      index: number,
+      key?: ?string,
+      actions: Array<NavigationNavigateAction>,
+      ...
+    }) => NavigationResetAction,
+    replace: (payload: {
+      key?: string,
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      ...
+    }) => NavigationReplaceAction,
+    completeTransition: (payload: { key?: string, ... }) => NavigationCompleteTransitionAction,
+    ...
+  };
+
+  declare export var DrawerActions: {
+    OPEN_DRAWER: 'Navigation/OPEN_DRAWER',
+    CLOSE_DRAWER: 'Navigation/CLOSE_DRAWER',
+    TOGGLE_DRAWER: 'Navigation/TOGGLE_DRAWER',
+    DRAWER_OPENED: 'Navigation/DRAWER_OPENED',
+    DRAWER_CLOSED: 'Navigation/DRAWER_CLOSED',
+    openDrawer: (payload: { key?: string, ... }) => NavigationOpenDrawerAction,
+    closeDrawer: (payload: { key?: string, ... }) => NavigationCloseDrawerAction,
+    toggleDrawer: (payload: { key?: string, ... }) => NavigationToggleDrawerAction,
+    ...
+  };
+
+  declare type _RouterProp<S: NavigationState, O: {...}> = { router: NavigationRouter<S, O>, ... };
+
+  declare type NavigationDescriptor = {
+    key: string,
+    state: NavigationLeafRoute | NavigationStateRoute,
+    navigation: NavigationScreenProp<any>,
+    getComponent: () => React$ComponentType<{...}>,
+    ...
+  };
+
+  declare type NavigationView<O, S> = React$ComponentType<{
+    descriptors: { [key: string]: NavigationDescriptor, ... },
+    navigation: NavigationScreenProp<S>,
+    ...
+  }>;
+
+  declare export function createNavigator<O: any, S: any, NavigatorConfig: any>(
+    view: NavigationView<O, S>,
+    router: NavigationRouter<S, O>,
+    navigatorConfig?: NavigatorConfig
+  ): NavigationNavigator<S, O, any>;
+
+  declare export function StackNavigator(
+    routeConfigMap: NavigationRouteConfigMap,
+    stackConfig?: StackNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+  declare export function createStackNavigator(
+    routeConfigMap: NavigationRouteConfigMap,
+    stackConfig?: StackNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+
+  declare type _TabViewConfig = {|
+    tabBarComponent?: React$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 export function createTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _TabNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+  /* TODO: fix the config for each of these tab navigator types */
+  declare export function createBottomTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _TabNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+  declare export function createMaterialTopTabNavigator(
+    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 export function createSwitchNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _SwitchNavigatorConfig
+  ): NavigationContainer<any, any, any>;
+
+  declare type _DrawerViewConfig = {|
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth?: number | (() => number),
+    drawerPosition?: 'left' | 'right',
+    contentComponent?: React$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 createDrawerNavigator(
+    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
+    ) => React$Node,
+    ...
+  };
+  declare export var Transitioner: React$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: React$ComponentType<
+    _CardStackTransitionerProps
+  >;
+
+  declare type _CardStackProps = {
+    screenProps?: {...},
+    headerMode: HeaderMode,
+    headerComponent?: React$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: React$ComponentType<_CardStackProps>;
+
+  declare type _CardProps = {
+    ...$Exact<NavigationSceneRendererProps>,
+    children: React$Node,
+    onComponentRef: React$Ref<any>,
+    pointerEvents: string,
+    style: any,
+    ...
+  };
+  declare export var Card: React$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?: React$Node,
+    style?: AnimatedViewStyleProp,
+    ...
+  };
+  declare export var SafeAreaView: React$ComponentType<_SafeAreaViewProps>;
+
+  declare export var Header: React$ComponentType<HeaderProps> & { HEIGHT: number, ... };
+
+  declare type _HeaderTitleProps = {
+    children: React$Node,
+    selectionColor?: string | number,
+    style?: AnimatedTextStyleProp,
+    ...
+  };
+  declare export var HeaderTitle: React$ComponentType<_HeaderTitleProps>;
+
+  declare type _HeaderBackButtonProps = {
+    onPress?: () => void,
+    pressColorAndroid?: string,
+    title?: ?string,
+    titleStyle?: ?TextStyleProp,
+    tintColor?: ?string,
+    truncatedTitle?: ?string,
+    width?: ?number,
+    ...
+  };
+  declare export var HeaderBackButton: React$ComponentType<
+    _HeaderBackButtonProps
+  >;
+
+  declare type _DrawerViewProps = {
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth: number | (() => number),
+    drawerPosition: 'left' | 'right',
+    contentComponent: React$ElementType,
+    contentOptions?: {...},
+    style?: ViewStyleProp,
+    useNativeAnimations: boolean,
+    drawerBackgroundColor: string,
+    screenProps?: {...},
+    navigation: NavigationScreenProp<NavigationState>,
+    router: NavigationRouter<NavigationState, NavigationDrawerScreenOptions>,
+    ...
+  };
+  declare export var DrawerView: React$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) => ?(React$Node | string),
+    renderIcon: (scene: _DrawerScene) => ?React$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: React$ComponentType<_DrawerItemsProps>;
+
+  declare type _TabViewProps = {
+    tabBarComponent?: React$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: React$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) => ?(React$Node | string),
+    getOnPress: (
+      previousScene: NavigationRoute,
+      scene: TabScene
+    ) => ({
+      previousScene: NavigationRoute,
+      scene: TabScene,
+      jumpToIndex: (index: number) => void,
+      ...
+    }) => void,
+    renderIcon: (scene: TabScene) => React$Element<any>,
+    labelStyle?: TextStyleProp,
+    iconStyle?: ViewStyleProp,
+    ...
+  };
+  declare export var TabBarTop: React$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) => ?(React$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) => React$Node,
+    style?: ViewStyleProp,
+    animateStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    tabStyle?: ViewStyleProp,
+    showIcon?: boolean,
+    ...
+  };
+  declare export var TabBarBottom: React$ComponentType<_TabBarBottomProps>;
+
+  declare export function withNavigation<Props: {...}>(
+    Component: React$ComponentType<Props>
+  ): React$ComponentType<
+    $Diff<
+      Props,
+      { navigation: NavigationScreenProp<NavigationStateRoute> | void, ... }
+    >
+  >;
+  declare export function withNavigationFocus<Props: {...}>(
+    Component: React$ComponentType<Props>
+  ): React$ComponentType<$Diff<Props, { isFocused: boolean | void, ... }>>;
+
+  declare export function getNavigation<State: NavigationState, Options: {...}>(
+    router: NavigationRouter<State, Options>,
+    state: State,
+    dispatch: NavigationDispatch,
+    actionSubscribers: Set<NavigationEventCallback>,
+    getScreenProps: () => {...},
+    getCurrentNavigation: () => ?NavigationScreenProp<State>
+  ): NavigationScreenProp<State>;
+}
diff --git a/definitions/npm/react-navigation_v2.x.x/flow_v0.201.x-/test_react-navigation.js b/definitions/npm/react-navigation_v2.x.x/flow_v0.201.x-/test_react-navigation.js
new file mode 100644
index 0000000000..e3c8f8bdbd
--- /dev/null
+++ b/definitions/npm/react-navigation_v2.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-navigation_v3.x.x/flow_v0.104.x-/react-navigation_v3.x.x.js b/definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-v0.200.x/react-navigation_v3.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-/react-navigation_v3.x.x.js
rename to definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-v0.200.x/react-navigation_v3.x.x.js
diff --git a/definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-/test_react-navigation.js b/definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-v0.200.x/test_react-navigation.js
similarity index 100%
rename from definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-/test_react-navigation.js
rename to definitions/npm/react-navigation_v3.x.x/flow_v0.104.x-v0.200.x/test_react-navigation.js
diff --git a/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/react-navigation_v3.x.x.js b/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/react-navigation_v3.x.x.js
new file mode 100644
index 0000000000..362a75271f
--- /dev/null
+++ b/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/react-navigation_v3.x.x.js
@@ -0,0 +1,1327 @@
+// @flow
+
+declare module 'react-navigation' {
+  /**
+   * 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 is 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 class AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // This is copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare class Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare class AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare class 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;
+  }
+
+  /**
+   * Next, all the type declarations
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<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>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<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?: ?(React$Node | (HeaderProps => React$Node)),
+    headerTransparent?: boolean,
+    headerTitle?: string | React$Node | React$ElementType,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: React$Node | React$ElementType,
+    headerBackTitle?: ?string,
+    headerBackImage?: React$Node | React$ElementType,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: React$Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: _SafeAreaViewInsets,
+    headerBackground?: React$Node | React$ElementType,
+    gesturesEnabled?: boolean,
+    gestureResponseDistance?: {
+      vertical?: number,
+      horizontal?: number,
+      ...
+    },
+    gestureDirection?: 'default' | 'inverted',
+    ...
+  };
+
+  declare export type NavigationStackRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    initialRouteKey?: string,
+  |};
+
+  declare export type NavigationStackViewConfig = {|
+    mode?: 'card' | 'modal',
+    headerMode?: HeaderMode,
+    headerTransitionPreset?: 'fade-in-place' | 'uikit',
+    headerLayoutPreset?: 'left' | 'center',
+    headerBackTitleVisible?: boolean,
+    cardShadowEnabled?: boolean,
+    cardOverlayEnabled?: boolean,
+    cardStyle?: ViewStyleProp,
+    transitionConfig?: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps,
+      isModal: boolean
+    ) => TransitionConfig,
+    onTransitionStart?: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps,
+    ) => void,
+    onTransitionEnd?: (
+      transitionProps: NavigationTransitionProps,
+      prevTransitionProps: ?NavigationTransitionProps,
+    ) => void,
+    transparentCard?: boolean,
+    disableKeyboardHandling?: boolean,
+  |};
+
+  declare export type StackNavigatorConfig = $Shape<{|
+    ...NavigationStackViewConfig,
+    ...NavigationStackRouterConfig,
+  |}>;
+
+  /**
+   * Switch Navigator
+   */
+
+  declare export type NavigationSwitchRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    defaultNavigationOptions?: 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,
+    defaultNavigationOptions?: 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?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    tabBarLabel?:
+      | string
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    tabBarVisible?: boolean,
+    tabBarTestIDProps?: {
+      testID?: string,
+      accessibilityLabel?: string,
+      ...
+    },
+    tabBarOnPress?: ({
+      navigation: NavigationScreenProp<NavigationRoute>,
+      defaultHandler: () => void,
+      ...
+    }) => void,
+  |};
+
+  /**
+   * Drawer
+   */
+
+  declare export type NavigationDrawerScreenOptions = {|
+    ...$Exact<NavigationScreenOptions>,
+    drawerIcon?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$Node),
+    drawerLabel?:
+      | React$Node
+      | ((options: {
+      tintColor: ?string,
+      focused: boolean,
+      ...
+    }) => ?React$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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    // Shared action creators that exist for all routers
+    goBack: (routeKey?: ?string) => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+        routeName: string,
+        params?: NavigationParams,
+        action?: NavigationNavigateAction,
+        key?: string,
+        ...
+      },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    // StackRouter action creators
+    pop?: (n?: number, params?: { immediate?: boolean, ... }) => boolean,
+    popToTop?: (params?: { immediate?: boolean, ... }) => boolean,
+    push?: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    replace?: (
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    reset?: (actions: NavigationAction[], index: number) => boolean,
+    dismiss?: () => boolean,
+    // DrawerRouter action creators
+    openDrawer?: () => boolean,
+    closeDrawer?: () => boolean,
+    toggleDrawer?: () => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: {...},
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationEvents component
+   */
+
+  declare type _NavigationEventsProps = {
+    navigation?: NavigationScreenProp<NavigationState>,
+    onWillFocus?: NavigationEventCallback,
+    onDidFocus?: NavigationEventCallback,
+    onWillBlur?: NavigationEventCallback,
+    onDidBlur?: NavigationEventCallback,
+    ...
+  };
+  declare export var NavigationEvents: React$ComponentType<
+    _NavigationEventsProps
+  >;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    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,
+    descriptor: ?NavigationDescriptor,
+    ...
+  };
+
+  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 : transition is happening.
+    //  progress.__getAnimatedValue() == 1 : transition 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 = () => React$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 createAppContainer<S: NavigationState, O: {...}>(
+    Component: NavigationNavigator<S, O, any>
+  ): NavigationContainer<S, O, any>;
+  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 var NavigationActions: {
+    BACK: 'Navigation/BACK',
+    INIT: 'Navigation/INIT',
+    NAVIGATE: 'Navigation/NAVIGATE',
+    SET_PARAMS: 'Navigation/SET_PARAMS',
+    back: (payload?: { key?: ?string, ... }) => NavigationBackAction,
+    init: (payload?: { params?: NavigationParams, ... }) => NavigationInitAction,
+    navigate: (payload: {
+      routeName: string,
+      params?: ?NavigationParams,
+      action?: ?NavigationNavigateAction,
+      key?: string,
+      ...
+    }) => NavigationNavigateAction,
+    setParams: (payload: {
+      key: string,
+      params: NavigationParams,
+      ...
+    }) => NavigationSetParamsAction,
+    ...
+  };
+
+  declare export var StackActions: {
+    POP: 'Navigation/POP',
+    POP_TO_TOP: 'Navigation/POP_TO_TOP',
+    PUSH: 'Navigation/PUSH',
+    RESET: 'Navigation/RESET',
+    REPLACE: 'Navigation/REPLACE',
+    COMPLETE_TRANSITION: 'Navigation/COMPLETE_TRANSITION',
+    pop: (payload: {
+      n?: number,
+      immediate?: boolean,
+      ...
+    }) => NavigationPopAction,
+    popToTop: (payload: {
+      immediate?: boolean,
+      key?: string,
+      ...
+    }) => NavigationPopToTopAction,
+    push: (payload: {
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      key?: string,
+      ...
+    }) => NavigationPushAction,
+    reset: (payload: {
+      index: number,
+      key?: ?string,
+      actions: Array<NavigationNavigateAction>,
+      ...
+    }) => NavigationResetAction,
+    replace: (payload: {
+      key?: string,
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      ...
+    }) => NavigationReplaceAction,
+    completeTransition: (payload: { key?: string, ... }) => NavigationCompleteTransitionAction,
+    ...
+  };
+
+  declare export var DrawerActions: {
+    OPEN_DRAWER: 'Navigation/OPEN_DRAWER',
+    CLOSE_DRAWER: 'Navigation/CLOSE_DRAWER',
+    TOGGLE_DRAWER: 'Navigation/TOGGLE_DRAWER',
+    DRAWER_OPENED: 'Navigation/DRAWER_OPENED',
+    DRAWER_CLOSED: 'Navigation/DRAWER_CLOSED',
+    openDrawer: (payload: { key?: string, ... }) => NavigationOpenDrawerAction,
+    closeDrawer: (payload: { key?: string, ... }) => NavigationCloseDrawerAction,
+    toggleDrawer: (payload: { key?: string, ... }) => NavigationToggleDrawerAction,
+    ...
+  };
+
+  declare type _RouterProp<S: NavigationState, O: {...}> = { router: NavigationRouter<S, O>, ... };
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<any>,
+    getComponent: () => React$ComponentType<{...}>,
+    ...
+  };
+
+  declare type NavigationView<O, S> = React$ComponentType<{
+    descriptors: { [key: string]: NavigationDescriptor, ... },
+    navigation: NavigationScreenProp<S>,
+    navigationConfig: any,
+    ...
+  }>;
+
+  declare export function createNavigator<O: any, S: any, NavigatorConfig: any>(
+    view: NavigationView<O, S>,
+    router: NavigationRouter<S, O>,
+    navigatorConfig?: NavigatorConfig
+  ): NavigationNavigator<S, O, any>;
+
+  declare export function createStackNavigator(
+    routeConfigMap: NavigationRouteConfigMap,
+    stackConfig?: StackNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare type _TabViewConfig = {|
+    tabBarComponent?: React$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,
+  |};
+  /* TODO: fix the config for each of these tab navigator types */
+  declare export function createBottomTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _TabNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+  declare export function createMaterialTopTabNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _TabNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+  declare type _SwitchNavigatorConfig = {|
+    ...NavigationSwitchRouterConfig,
+  |};
+  declare export function createSwitchNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _SwitchNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare type _DrawerViewConfig = {|
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth?: number | (() => number),
+    drawerPosition?: 'left' | 'right',
+    contentComponent?: React$ElementType,
+    contentOptions?: {...},
+    style?: ViewStyleProp,
+    useNativeAnimations?: boolean,
+    drawerBackgroundColor?: string,
+    overlayColor?: string,
+    screenProps?: {...},
+  |};
+  declare type _DrawerNavigatorConfig = $Exact<{
+    ...NavigationTabRouterConfig,
+    ..._DrawerViewConfig,
+    containerConfig?: void,
+    ...
+  }>;
+  declare export function createDrawerNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _DrawerNavigatorConfig
+  ): NavigationNavigator<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
+    ) => React$Node,
+    ...
+  };
+  declare export var Transitioner: React$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: React$ComponentType<
+    _CardStackTransitionerProps
+  >;
+
+  declare type _CardStackProps = {
+    screenProps?: {...},
+    headerMode: HeaderMode,
+    headerComponent?: React$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: React$ComponentType<_CardStackProps>;
+
+  declare type _CardProps = {
+    ...$Exact<NavigationSceneRendererProps>,
+    children: React$Node,
+    onComponentRef: React$Ref<any>,
+    pointerEvents: string,
+    style: any,
+    ...
+  };
+  declare export var Card: React$ComponentType<_CardProps>;
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewInsets = $Shape<{
+    top: _SafeAreaViewForceInsetValue,
+    bottom: _SafeAreaViewForceInsetValue,
+    left: _SafeAreaViewForceInsetValue,
+    right: _SafeAreaViewForceInsetValue,
+    vertical: _SafeAreaViewForceInsetValue,
+    horizontal: _SafeAreaViewForceInsetValue,
+    ...
+  }>;
+  declare type _SafeAreaViewProps = {
+    forceInset?: _SafeAreaViewInsets,
+    children?: React$Node,
+    style?: AnimatedViewStyleProp,
+    ...
+  };
+  declare export var SafeAreaView: React$ComponentType<_SafeAreaViewProps>;
+
+  declare export var Header: React$ComponentType<HeaderProps> & { HEIGHT: number, ... };
+
+  declare type _HeaderTitleProps = {
+    children: React$Node,
+    selectionColor?: string | number,
+    style?: AnimatedTextStyleProp,
+    ...
+  };
+  declare export var HeaderTitle: React$ComponentType<_HeaderTitleProps>;
+
+  declare type _HeaderBackButtonProps = {
+    onPress?: () => void,
+    pressColorAndroid?: string,
+    title?: ?string,
+    titleStyle?: ?TextStyleProp,
+    tintColor?: ?string,
+    truncatedTitle?: ?string,
+    width?: ?number,
+    ...
+  };
+  declare export var HeaderBackButton: React$ComponentType<
+    _HeaderBackButtonProps
+  >;
+
+  declare type _DrawerViewProps = {
+    drawerLockMode?: 'unlocked' | 'locked-closed' | 'locked-open',
+    drawerWidth: number | (() => number),
+    drawerPosition: 'left' | 'right',
+    contentComponent: React$ElementType,
+    contentOptions?: {...},
+    style?: ViewStyleProp,
+    useNativeAnimations: boolean,
+    drawerBackgroundColor: string,
+    screenProps?: {...},
+    navigation: NavigationScreenProp<NavigationState>,
+    router: NavigationRouter<NavigationState, NavigationDrawerScreenOptions>,
+    ...
+  };
+  declare export var DrawerView: React$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) => ?(React$Node | string),
+    renderIcon: (scene: _DrawerScene) => ?React$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: React$ComponentType<_DrawerItemsProps>;
+
+  declare type _TabViewProps = {
+    tabBarComponent?: React$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: React$ComponentType<_TabViewProps>;
+
+  declare type _MaterialTopTabBarProps = {
+    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) => ?(React$Node | string),
+    getOnPress: (
+      previousScene: NavigationRoute,
+      scene: TabScene
+    ) => ({
+      previousScene: NavigationRoute,
+      scene: TabScene,
+      jumpToIndex: (index: number) => void,
+      ...
+    }) => void,
+    renderIcon: (scene: TabScene) => React$Element<any>,
+    labelStyle?: TextStyleProp,
+    iconStyle?: ViewStyleProp,
+    ...
+  };
+  declare export var MaterialTopTabBar: React$ComponentType<
+    _MaterialTopTabBarProps
+  >;
+
+  declare type _BottomTabBarButtonComponentProps = {
+    onPress: () => void,
+    onLongPress: () => void,
+    testID: string,
+    accessibilityLabel: string,
+    style: ViewStyleProp,
+    ...
+  };
+  declare type _BottomTabBarProps = {
+    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) => ?(React$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) => React$Node,
+    getButtonComponent: (
+      scene: TabScene
+    ) => React$ComponentType<_BottomTabBarButtonComponentProps>,
+    style?: ViewStyleProp,
+    animateStyle?: ViewStyleProp,
+    labelStyle?: TextStyleProp,
+    tabStyle?: ViewStyleProp,
+    showIcon?: boolean,
+    ...
+  };
+  declare export var BottomTabBar: React$ComponentType<_BottomTabBarProps>;
+
+  declare export function withNavigation<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<
+    $Diff<
+      React$ElementConfig<ComponentType>,
+      { navigation: NavigationScreenProp<NavigationStateRoute> | void, ... }
+    >
+  >;
+  declare export function withNavigationFocus<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<$Diff<React$ElementConfig<ComponentType>, { isFocused: boolean | void, ... }>>;
+
+  declare export function getNavigation<State: NavigationState, Options: {...}>(
+    router: NavigationRouter<State, Options>,
+    state: State,
+    dispatch: NavigationDispatch,
+    actionSubscribers: Set<NavigationEventCallback>,
+    getScreenProps: () => {...},
+    getCurrentNavigation: () => ?NavigationScreenProp<State>
+  ): NavigationScreenProp<State>;
+
+  declare export function getActiveChildNavigationOptions<
+    State: NavigationState,
+    Options: {...}
+  >(
+    navigation: NavigationScreenProp<State>,
+    screenProps?: {...}
+  ): Options;
+}
diff --git a/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/test_react-navigation.js b/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/test_react-navigation.js
new file mode 100644
index 0000000000..ee4670ab4c
--- /dev/null
+++ b/definitions/npm/react-navigation_v3.x.x/flow_v0.201.x-/test_react-navigation.js
@@ -0,0 +1,194 @@
+// @flow
+
+import type {
+  NavigationScreenProp,
+} from 'react-navigation';
+
+import {
+  createBottomTabNavigator,
+  createStackNavigator,
+  createDrawerNavigator,
+  StackRouter,
+  TabRouter,
+} from 'react-navigation';
+import React from 'react';
+
+/**
+ * Screens
+ */
+
+const FunctionalScreenComponent = (
+  { navigation }: { navigation: NavigationScreenProp<any>, ... },
+) => {
+  return "Test";
+};
+createBottomTabNavigator({
+  Test1: { screen: FunctionalScreenComponent },
+});
+
+class ClassScreenComponent extends React.Component<any> {
+  render() {
+    return "Test";
+  }
+}
+createStackNavigator({
+  Test1: { screen: ClassScreenComponent },
+});
+
+// $FlowExpectedError numbers can never be components
+createStackNavigator({
+  Test1: { screen: 5 },
+});
+
+// $FlowExpectedError you need a screen!
+createBottomTabNavigator({
+  Test1: { blah: "test" },
+});
+
+createDrawerNavigator({
+  Test1: { getScreen: () => FunctionalScreenComponent },
+});
+
+/**
+ * Configs
+ */
+
+createStackNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    mode: "card",
+    initialRouteName: "Test1",
+    cardShadowEnabled: false,
+    cardOverlayEnabled: false,
+  },
+);
+
+createStackNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError stack not drawer!
+  {
+    initialRouteName: "Test1",
+    drawerBackgroundColor: "green",
+  },
+);
+
+createBottomTabNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError tab not drawer!
+  {
+    drawerBackgroundColor: "green",
+  },
+);
+
+createBottomTabNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    initialRouteName: "Test1",
+  },
+);
+
+createDrawerNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  {
+    drawerBackgroundColor: "green",
+  },
+);
+
+createDrawerNavigator(
+  {
+    Test1: { screen: FunctionalScreenComponent },
+  },
+  // $FlowExpectedError drawer not tab!
+  {
+    tabBarPosition: "top",
+  },
+);
+
+/**
+ * Nav options
+ */
+
+createStackNavigator({
+  Test1: {
+    screen: FunctionalScreenComponent,
+    navigationOptions: {
+      headerTitle: 'Home',
+    },
+  },
+});
+
+class ComponentWithNavOptions extends React.Component<any> {
+  static navigationOptions = {
+    headerTitle: "Home",
+  };
+  render() {
+    return "Test";
+  }
+}
+createStackNavigator({
+  Test1: { screen: ComponentWithNavOptions },
+});
+
+class ComponentWithFunctionalNavOptions extends React.Component<any> {
+  static navigationOptions = (
+    { navigation }: { navigation: NavigationScreenProp<any>, ... },
+  ) => ({
+    headerTitle: navigation.state.routeName,
+  });
+  render() {
+    return "Test";
+  }
+}
+
+/**
+ * Nested
+ */
+
+const innerRouteConfig = {
+  Test1: { screen: FunctionalScreenComponent },
+};
+const nestedNavigator = createBottomTabNavigator(innerRouteConfig);
+const outerRouteConfig = {
+  Test2: { screen: nestedNavigator },
+  Test3: { screen: ClassScreenComponent },
+};
+createStackNavigator(outerRouteConfig);
+
+/**
+ * StackRouter
+ */
+
+const stackRouter = StackRouter(innerRouteConfig);
+const stackNavigateAction = {
+  type: "Navigation/NAVIGATE",
+  routeName: "Test3",
+};
+stackRouter.getStateForAction(stackNavigateAction, null);
+
+/**
+ * TabRouter
+ */
+
+const tabRouter = TabRouter(innerRouteConfig);
+const tabNavigateAction = {
+  type: "Navigation/NAVIGATE",
+  routeName: "Test1",
+};
+tabRouter.getStateForAction(tabNavigateAction, null);
+
+const fakeNavigateAction = {
+  fake: "Navigation/NAVIGATE",
+  blah: "Test1",
+};
+// $FlowExpectedError not a valid action!
+tabRouter.getStateForAction(fakeNavigateAction, null);
diff --git a/definitions/npm/react-navigation_v4.x.x/flow_v0.104.x-/react-navigation_v4.x.x.js b/definitions/npm/react-navigation_v4.x.x/flow_v0.104.x-v0.200.x/react-navigation_v4.x.x.js
similarity index 100%
rename from definitions/npm/react-navigation_v4.x.x/flow_v0.104.x-/react-navigation_v4.x.x.js
rename to definitions/npm/react-navigation_v4.x.x/flow_v0.104.x-v0.200.x/react-navigation_v4.x.x.js
diff --git a/definitions/npm/react-navigation_v4.x.x/flow_v0.201.x-/react-navigation_v4.x.x.js b/definitions/npm/react-navigation_v4.x.x/flow_v0.201.x-/react-navigation_v4.x.x.js
new file mode 100644
index 0000000000..9941d66f87
--- /dev/null
+++ b/definitions/npm/react-navigation_v4.x.x/flow_v0.201.x-/react-navigation_v4.x.x.js
@@ -0,0 +1,981 @@
+// @flow
+
+declare module 'react-navigation' {
+
+  //---------------------------------------------------------------------------
+  // 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.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 1A
+   * 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;
+
+  /**
+   * SECTION 1B
+   * The following are type declarations for core types necessary for every
+   * React Navigation libdef.
+   */
+
+  /**
+   * Navigation State + Action
+   */
+
+  declare export type NavigationParams = { [key: string]: mixed, ... };
+
+  declare export type NavigationBackAction = {|
+    type: 'Navigation/BACK',
+    key?: ?string,
+  |};
+  declare export type NavigationInitAction = {|
+    type: 'Navigation/INIT',
+    params?: NavigationParams,
+  |};
+  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 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 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 NavigationResetAction = {|
+    type: 'Navigation/RESET',
+    index: number,
+    key?: ?string,
+    actions: Array<NavigationNavigateAction>,
+  |};
+  declare export type NavigationReplaceAction = {|
+    +type: 'Navigation/REPLACE',
+    +key: string,
+    +routeName: string,
+    +params?: NavigationParams,
+    +action?: NavigationNavigateAction,
+  |};
+  declare export type NavigationCompleteTransitionAction = {|
+    +type: 'Navigation/COMPLETE_TRANSITION',
+    +key?: string,
+    +toChildKey?: string,
+  |};
+
+  declare export type NavigationOpenDrawerAction = {|
+    +type: 'Navigation/OPEN_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationCloseDrawerAction = {|
+    +type: 'Navigation/CLOSE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationToggleDrawerAction = {|
+    +type: 'Navigation/TOGGLE_DRAWER',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerOpenedAction = {|
+    +type: 'Navigation/DRAWER_OPENED',
+    +key?: string,
+  |};
+  declare export type NavigationDrawerClosedAction = {|
+    +type: 'Navigation/DRAWER_CLOSED',
+    +key?: string,
+  |};
+
+  declare export type NavigationJumpToAction = {|
+    +type: 'Navigation/JUMP_TO';
+    +preserveFocus: boolean,
+    +routeName: string,
+    +key?: string,
+    +params?: NavigationParams,
+  |};
+
+  declare export type NavigationAction =
+    | NavigationBackAction
+    | NavigationInitAction
+    | NavigationNavigateAction
+    | NavigationSetParamsAction
+    | NavigationPopAction
+    | NavigationPopToTopAction
+    | NavigationPushAction
+    | NavigationResetAction
+    | NavigationReplaceAction
+    | NavigationCompleteTransitionAction
+    | NavigationOpenDrawerAction
+    | NavigationCloseDrawerAction
+    | NavigationToggleDrawerAction
+    | NavigationDrawerOpenedAction
+    | NavigationDrawerClosedAction
+    | NavigationJumpToAction;
+
+  /**
+   * 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>,
+    isTransitioning?: bool,
+    ...
+  };
+
+  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,
+    ...$Exact<NavigationState>,
+  |};
+
+  /**
+   * Router
+   */
+
+  declare export type NavigationScreenProps = { [key: string]: mixed, ... };
+
+  declare export type NavigationScreenOptionsGetter<Options: {...}> = (
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: ?NavigationScreenProps,
+    theme: SupportedThemes,
+  ) => 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 NavigationScreenOptions = { title?: string, ... };
+
+  declare export type SupportedThemes = 'light' | 'dark';
+
+  declare export type NavigationScreenConfigProps = $Shape<{|
+    navigation: NavigationScreenProp<NavigationRoute>,
+    screenProps: NavigationScreenProps,
+    theme: SupportedThemes,
+  |}>;
+
+  declare export type NavigationScreenConfig<Options> =
+    | Options
+    | (({|
+        ...NavigationScreenConfigProps,
+        navigationOptions: Options,
+      |}) => Options);
+
+  declare export type NavigationComponent =
+    | NavigationScreenComponent<NavigationRoute, any, any>
+    | NavigationNavigator<any, any, any>;
+
+  declare interface withOptionalNavigationOptions<Options> {
+    navigationOptions?: NavigationScreenConfig<Options>;
+  }
+
+  declare export type NavigationScreenComponent<
+    Route: NavigationRoute,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, Route>,
+  > = React$ComponentType<Props> &
+    withOptionalNavigationOptions<Options>;
+
+  declare interface withRouter<State, Options> {
+    router: NavigationRouter<State, Options>;
+  }
+
+  declare export type NavigationNavigator<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationNavigatorProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare type _NavigationRouteConfigCore = {|
+    navigationOptions?: NavigationScreenConfig<any>,
+    params?: NavigationParams,
+    path?: string,
+  |};
+  declare export type NavigationRouteConfig =
+    | NavigationComponent
+    | {| ..._NavigationRouteConfigCore, screen: NavigationComponent |}
+    | {| ..._NavigationRouteConfigCore, getScreen: () => NavigationComponent |};
+
+  declare export type NavigationRouteConfigMap = { [routeName: string]: NavigationRouteConfig, ... };
+
+  /**
+   * Navigator Prop
+   */
+
+  declare export type NavigationDispatch = (
+    action: NavigationAction
+  ) => boolean;
+
+  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,
+    addListener: (
+      eventName: string,
+      callback: NavigationEventCallback
+    ) => NavigationEventSubscription,
+    getParam: <ParamName: string>(
+      paramName: ParamName,
+      fallback?: $ElementType<
+        $PropertyType<
+          {|
+            ...{| params: {...} |},
+            ...$Exact<S>,
+          |},
+          'params'
+        >,
+        ParamName
+      >
+    ) => $ElementType<
+      $PropertyType<
+        {|
+          ...{| params: {...} |},
+          ...$Exact<S>,
+        |},
+        'params'
+      >,
+      ParamName
+    >,
+    dangerouslyGetParent: () => ?NavigationScreenProp<NavigationState>,
+    isFocused: () => boolean,
+    goBack: (routeKey?: ?string) => boolean,
+    dismiss: () => boolean,
+    navigate: (
+      routeName:
+        | string
+        | {
+            routeName: string,
+            params?: NavigationParams,
+            action?: NavigationNavigateAction,
+            key?: string,
+            ...
+          },
+      params?: NavigationParams,
+      action?: NavigationNavigateAction
+    ) => boolean,
+    setParams: (newParams: NavigationParams) => boolean,
+    ...
+  };
+
+  declare export type NavigationNavigatorProps<O: {...}, S: {...}> = $Shape<{
+    navigation: NavigationScreenProp<S>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    theme?: SupportedThemes | 'no-preference',
+    detached?: boolean,
+    ...
+  }>;
+
+  /**
+   * Navigation container
+   */
+
+  declare export type NavigationContainer<
+    State: NavigationState,
+    Options: {...},
+    Props: NavigationContainerProps<Options, State>,
+  > = React$ComponentType<Props> &
+    withRouter<State, Options> &
+    withOptionalNavigationOptions<Options>;
+
+  declare export type NavigationContainerProps<S: {...}, O: {...}> = $Shape<{
+    uriPrefix?: string | RegExp,
+    onNavigationStateChange?: ?(
+      NavigationState,
+      NavigationState,
+      NavigationAction
+    ) => void,
+    navigation?: NavigationScreenProp<S>,
+    persistenceKey?: ?string,
+    renderLoadingExperimental?: React$ComponentType<{...}>,
+    screenProps?: NavigationScreenProps,
+    navigationOptions?: O,
+    ...
+  }>;
+
+  /**
+   * NavigationDescriptor
+   */
+
+  declare export type NavigationDescriptor = {
+    key: string,
+    state: NavigationRoute,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    getComponent: () => NavigationComponent,
+    ...
+  };
+
+  declare export type NavigationDescriptorMap = {
+    [key: string]: NavigationDescriptor,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 2: SHARED TYPE DEFINITIONS
+  // This section too is copy-pasted, but it's not identical across all React
+  // Navigation libdefs. We pick out bits and pieces that we need.
+  //---------------------------------------------------------------------------
+
+  /**
+   * SECTION 2A
+   * We start with definitions we have copy-pasted, either from in-package
+   * types, other Flow libdefs, or from TypeScript types somewhere.
+   */
+
+  // This is 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 class AnimatedInterpolation {
+    interpolate(config: InterpolationConfigType): AnimatedInterpolation;
+  }
+
+  // This is copied from
+  // react-native/Libraries/Animated/src/animations/Animation.js
+  declare type EndResult = { finished: boolean, ... };
+  declare type EndCallback = (result: EndResult) => void;
+  declare class Animation {
+    start(
+      fromValue: number,
+      onUpdate: (value: number) => void,
+      onEnd: ?EndCallback,
+      previousAnimation: ?Animation,
+      animatedValue: AnimatedValue,
+    ): void;
+    stop(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedTracking.js
+  declare class AnimatedTracking {
+    constructor(
+      value: AnimatedValue,
+      parent: any,
+      animationClass: any,
+      animationConfig: Object,
+      callback?: ?EndCallback,
+    ): void;
+    update(): void;
+  }
+
+  // This is vaguely copied from
+  // react-native/Libraries/Animated/src/nodes/AnimatedValue.js
+  declare type ValueListenerCallback = (state: { value: number, ... }) => void;
+  declare class 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;
+  }
+
+  /**
+   * SECTION 2B
+   * The following are the actually useful definitions in Section 2, that are
+   * used below in section 3, but also in other libdefs.
+   */
+
+  declare export type NavigationPathsConfig = { [routeName: string]: string, ... };
+
+  /**
+   * SafeAreaView
+   */
+
+  declare type _SafeAreaViewForceInsetValue = 'always' | 'never' | number;
+  declare type _SafeAreaViewInsets = $Shape<{|
+    top: _SafeAreaViewForceInsetValue,
+    bottom: _SafeAreaViewForceInsetValue,
+    left: _SafeAreaViewForceInsetValue,
+    right: _SafeAreaViewForceInsetValue,
+    vertical: _SafeAreaViewForceInsetValue,
+    horizontal: _SafeAreaViewForceInsetValue,
+  |}>;
+
+  /**
+   * Interpolation
+   */
+
+  declare export type NavigationStackInterpolatorProps = $Shape<{|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode?: HeaderMode,
+    shadowEnabled?: boolean,
+    cardOverlayEnabled?: boolean,
+  |}>;
+
+  declare type _InterpolationResult = { [key: string]: mixed, ... };
+  declare export type NavigationStackInterpolator =
+    (props: NavigationStackInterpolatorProps) => _InterpolationResult;
+
+  /**
+   * Header
+   */
+
+  declare export type HeaderMode = 'float' | 'screen' | 'none';
+
+  declare export type HeaderProps = {|
+    layout: NavigationStackLayout,
+    scene: NavigationStackScene,
+    scenes: NavigationStackScene[],
+    position: AnimatedInterpolation,
+    navigation: NavigationStackProp<NavigationState>,
+    mode: HeaderMode,
+    leftInterpolator?: NavigationStackInterpolator,
+    titleInterpolator?: NavigationStackInterpolator,
+    rightInterpolator?: NavigationStackInterpolator,
+    backgroundInterpolator?: NavigationStackInterpolator,
+    layoutPreset: 'left' | 'center',
+    transitionPreset?: 'fade-in-place' | 'uikit',
+    backTitleVisible?: boolean,
+    isLandscape: boolean,
+  |};
+
+  /**
+   * StackRouter
+   */
+
+  declare export type NavigationStackProp<+S> =
+    & NavigationScreenProp<S>
+    & {
+        pop: (n?: number, params?: {| immediate?: boolean |}) => boolean,
+        popToTop: (params?: {| immediate?: boolean |}) => boolean,
+        push: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        replace: (
+          routeName: string,
+          params?: NavigationParams,
+          action?: NavigationNavigateAction
+        ) => boolean,
+        reset: (actions: NavigationAction[], index: number) => boolean,
+        ...
+      };
+
+  declare type _HeaderBackButtonProps = {|
+    disabled?: boolean,
+    onPress: () => void,
+    pressColorAndroid?: string,
+    tintColor?: ?string,
+    backImage?: React$ComponentType<{
+      tintColor: string,
+      title?: ?string,
+      ...
+    }>,
+    title?: ?string,
+    truncatedTitle?: ?string,
+    backTitleVisible?: boolean,
+    allowFontScaling?: boolean,
+    titleStyle?: ?TextStyleProp,
+    headerLayoutPreset: 'left' | 'center',
+    width?: ?number,
+    scene: NavigationStackScene,
+  |};
+
+  declare export type NavigationStackScreenOptions = NavigationScreenOptions & {
+    header?: ?(React$Node | (HeaderProps => React$Node)),
+    headerTransparent?: boolean,
+    headerTitle?: (props: { children: ?string, ... }) => React$Node | React$Node,
+    headerTitleStyle?: AnimatedTextStyleProp,
+    headerTitleAllowFontScaling?: boolean,
+    headerTintColor?: string,
+    headerLeft?: ((props: _HeaderBackButtonProps) => React$Node) | React$Node,
+    headerBackTitle?: ?string,
+    headerBackImage?: (props: {|
+      tintColor?: string,
+      title?: ?string,
+    |}) => React$Node,
+    headerTruncatedBackTitle?: string,
+    headerBackTitleStyle?: TextStyleProp,
+    headerPressColorAndroid?: string,
+    headerRight?: React$Node,
+    headerStyle?: ViewStyleProp,
+    headerForceInset?: _SafeAreaViewInsets,
+    headerBackground?: React$Node | React$ElementType,
+    gesturesEnabled?: boolean,
+    gestureResponseDistance?: {|
+      vertical?: number,
+      horizontal?: number,
+    |},
+    gestureDirection?: 'default' | 'inverted',
+    ...
+  };
+
+  declare export type NavigationStackRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    initialRouteKey?: string,
+  |};
+
+  /**
+   * Stack Gestures, Animations, and Interpolators
+   */
+
+  declare export type NavigationStackLayout = {
+    height: AnimatedValue,
+    initHeight: number,
+    initWidth: number,
+    isMeasured: boolean,
+    width: AnimatedValue,
+    ...
+  };
+
+  declare export type NavigationStackScene = {
+    index: number,
+    isActive: boolean,
+    isStale: boolean,
+    key: string,
+    route: NavigationRoute,
+    descriptor: ?NavigationDescriptor,
+    ...
+  };
+
+  /**
+   * SwitchRouter
+   */
+
+  declare export type NavigationSwitchRouterConfig = {|
+    initialRouteName?: string,
+    initialRouteParams?: NavigationParams,
+    paths?: NavigationPathsConfig,
+    navigationOptions?: NavigationScreenConfig<any>,
+    defaultNavigationOptions?: NavigationScreenConfig<any>,
+    // todo: type these as the real route names rather than 'string'
+    order?: string[],
+    // Does the back button cause the router to switch to the initial tab
+    backBehavior?: 'none' | 'initialRoute' | 'history' | 'order', // defaults `initialRoute`
+    resetOnBlur?: boolean,
+  |};
+
+  /**
+   * TabRouter
+   */
+
+  declare export type NavigationTabProp<+S> =
+    & NavigationScreenProp<S>
+    & { jumpTo: (routeName: string, key?: string) => void, ... };
+
+  declare export type NavigationTabRouterConfig = NavigationSwitchRouterConfig;
+
+  declare export type NavigationTabScreenOptions = {
+    ...$Exact<NavigationScreenOptions>,
+    tabBarLabel?: React$Node,
+    tabBarVisible?: boolean,
+    tabBarAccessibilityLabel?: string,
+    tabBarTestID?: string,
+    tabBarIcon?:
+      | React$Node
+      | ((props: {|
+          focused: boolean,
+          tintColor?: string,
+          horizontal?: boolean,
+        |}) => React$Node),
+    tabBarOnPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    tabBarOnLongPress?: (props: {|
+      navigation: NavigationTabProp<NavigationRoute>,
+      defaultHandler: () => void,
+    |}) => void,
+    ...
+  };
+
+  //---------------------------------------------------------------------------
+  // SECTION 3: UNIQUE TYPE DEFINITIONS
+  // This section normally contains exported types that are not present in any
+  // other React Navigation libdef. But the main react-navigation libdef doesn't
+  // have any, so it's empty here.
+  //---------------------------------------------------------------------------
+
+  //---------------------------------------------------------------------------
+  // SECTION 4: EXPORTED MODULE
+  // This is the only section that types exports. Other sections export types,
+  // but this section types the module's exports.
+  //---------------------------------------------------------------------------
+
+  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 getNavigation<State: NavigationState, Options: {...}>(
+    router: NavigationRouter<State, Options>,
+    state: State,
+    dispatch: NavigationDispatch,
+    actionSubscribers: Set<NavigationEventCallback>,
+    getScreenProps: () => {...},
+    getCurrentNavigation: () => ?NavigationScreenProp<State>
+  ): NavigationScreenProp<State>;
+
+  declare type _NavigationView<O, S, N: NavigationScreenProp<S>> = React$ComponentType<{
+    descriptors: NavigationDescriptorMap,
+    navigation: N,
+    navigationConfig: any,
+    ...
+  }>;
+  declare export function createNavigator<O: any, S: any, NavigatorConfig: any, N: NavigationScreenProp<S>>(
+    view: _NavigationView<O, S, N>,
+    router: NavigationRouter<S, O>,
+    navigatorConfig?: NavigatorConfig
+  ): NavigationNavigator<S, O, any>;
+
+  declare export var NavigationContext: React$Context<
+    ?NavigationScreenProp<NavigationState | NavigationRoute>,
+  >;
+  declare export var NavigationProvider: $PropertyType<typeof NavigationContext, 'Provider'>;
+  declare export var NavigationConsumer: $PropertyType<typeof NavigationContext, 'Consumer'>;
+
+  declare type _SwitchNavigatorConfig = NavigationSwitchRouterConfig;
+  declare export function createSwitchNavigator(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: _SwitchNavigatorConfig
+  ): NavigationNavigator<any, any, any>;
+
+  declare export var ThemeContext: React$Context<SupportedThemes>;
+  declare export var ThemeProvider: $PropertyType<typeof ThemeContext, 'Provider'>;
+  declare export var ThemeConsumer: $PropertyType<typeof ThemeContext, 'Consumer'>;
+  declare export var ThemeColors: { [theme: SupportedThemes]: { [key: string]: string, ... }, ... };
+  declare export function useTheme(): SupportedThemes;
+
+  declare export var NavigationActions: {|
+    BACK: 'Navigation/BACK',
+    INIT: 'Navigation/INIT',
+    NAVIGATE: 'Navigation/NAVIGATE',
+    SET_PARAMS: 'Navigation/SET_PARAMS',
+    back: (payload?: {| key?: ?string |}) => NavigationBackAction,
+    init: (payload?: {| params?: NavigationParams |}) => NavigationInitAction,
+    navigate: (payload: {|
+      routeName: string,
+      params?: ?NavigationParams,
+      action?: ?NavigationNavigateAction,
+      key?: string,
+    |}) => NavigationNavigateAction,
+    setParams: (payload: {|
+      key: string,
+      params: NavigationParams,
+    |}) => NavigationSetParamsAction,
+  |};
+
+  declare export var StackActions: {|
+    POP: 'Navigation/POP',
+    POP_TO_TOP: 'Navigation/POP_TO_TOP',
+    PUSH: 'Navigation/PUSH',
+    RESET: 'Navigation/RESET',
+    REPLACE: 'Navigation/REPLACE',
+    COMPLETE_TRANSITION: 'Navigation/COMPLETE_TRANSITION',
+    pop: (payload: {|
+      n?: number,
+      immediate?: boolean,
+    |}) => NavigationPopAction,
+    popToTop: (payload: {|
+      immediate?: boolean,
+      key?: string,
+    |}) => NavigationPopToTopAction,
+    push: (payload: {|
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+      key?: string,
+    |}) => NavigationPushAction,
+    reset: (payload: {|
+      index: number,
+      key?: ?string,
+      actions: Array<NavigationNavigateAction>,
+    |}) => NavigationResetAction,
+    replace: (payload: {|
+      key?: string,
+      routeName: string,
+      params?: NavigationParams,
+      action?: NavigationNavigateAction,
+    |}) => NavigationReplaceAction,
+    completeTransition: (payload: {|
+      key?: string,
+      toChildKey?: string,
+    |}) => NavigationCompleteTransitionAction,
+  |};
+
+  declare export var SwitchActions: {|
+    JUMP_TO: 'Navigation/JUMP_TO',
+    jumpTo: (payload: {|
+      routeName: string,
+      key?: string,
+      params?: NavigationParams,
+    |}) => NavigationJumpToAction,
+  |};
+
+  declare export function StackRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationStackRouterConfig
+  ): NavigationRouter<any, NavigationStackScreenOptions>;
+
+  declare export function TabRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    config?: NavigationTabRouterConfig
+  ): NavigationRouter<any, NavigationTabScreenOptions>;
+
+  declare export function SwitchRouter(
+    routeConfigs: NavigationRouteConfigMap,
+    stackConfig?: NavigationSwitchRouterConfig
+  ): NavigationRouter<any, {| |}>;
+
+  declare export function getActiveChildNavigationOptions<
+    State: NavigationState,
+    Options: {...}
+  >(
+    navigation: NavigationScreenProp<State>,
+    screenProps?: NavigationScreenProps,
+    theme?: SupportedThemes,
+  ): Options;
+
+  declare type _SceneViewProps = {
+    component: React$ComponentType<{
+      screenProps: ?NavigationScreenProps,
+      navigation: NavigationScreenProp<NavigationRoute>,
+      ...
+    }>,
+    screenProps: ?NavigationScreenProps,
+    navigation: NavigationScreenProp<NavigationRoute>,
+    ...
+  };
+  declare export var SceneView: React$ComponentType<_SceneViewProps>;
+
+  declare type _NavigationEventsProps = {
+    navigation?: NavigationScreenProp<NavigationState>,
+    onWillFocus?: NavigationEventCallback,
+    onDidFocus?: NavigationEventCallback,
+    onWillBlur?: NavigationEventCallback,
+    onDidBlur?: NavigationEventCallback,
+    ...
+  };
+  declare export var NavigationEvents: React$ComponentType<
+    _NavigationEventsProps
+  >;
+
+  declare export function withNavigation<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<
+    $Diff<
+      React$ElementConfig<ComponentType>,
+      {| navigation: NavigationScreenProp<NavigationStateRoute> |}
+    >
+  >;
+  declare export function withNavigationFocus<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<$Diff<React$ElementConfig<ComponentType>, {| isFocused: ?boolean |}>>;
+
+  declare export function createAppContainer<S: NavigationState, O: {...}>(
+    Component: NavigationNavigator<S, O, any>
+  ): NavigationContainer<S, O, any>;
+
+  declare export function createKeyboardAwareNavigator<Props: {...}>(
+    Comp: React$ComponentType<Props>,
+    stackConfig: {...}
+  ): React$ComponentType<Props>;
+
+  declare export function withOrientation<Props: {...}, ComponentType: React$ComponentType<Props>>(
+    Component: ComponentType
+  ): React$ComponentType<$Diff<React$ElementConfig<ComponentType>, {| isLandscape: boolean |}>>;
+
+  declare type _SafeAreaViewProps = {
+    forceInset?: _SafeAreaViewInsets,
+    children?: React$Node,
+    style?: AnimatedViewStyleProp,
+    ...
+  };
+  declare export var SafeAreaView: React$ComponentType<_SafeAreaViewProps>;
+
+  // These components take the same props that their React Native primitives do
+  // Typing them correctly would be extremely brittle
+  // We await the day we can import types from libraries in flow-typed libdefs
+  declare export var ScrollView: React$ComponentType<{...}>;
+  declare export var FlatList: React$ComponentType<{...}>;
+  declare export var SectionList: React$ComponentType<{...}>;
+  declare export var Themed: {|
+    StatusBar: React$ComponentType<{...}>,
+    Text: React$ComponentType<{...}>,
+    TextInput: React$ComponentType<{...}>,
+  |};
+
+}
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/redux-loop_v2.2.x.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/redux-loop_v2.2.x.js
similarity index 100%
rename from definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/redux-loop_v2.2.x.js
rename to definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/redux-loop_v2.2.x.js
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_combineReducers.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_combineReducers.js
similarity index 100%
rename from definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_combineReducers.js
rename to definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_combineReducers.js
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_effects.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_effects.js
similarity index 100%
rename from definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_effects.js
rename to definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_effects.js
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_loop.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_loop.js
similarity index 100%
rename from definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-/test_loop.js
rename to definitions/npm/redux-loop_v2.2.x/flow_v0.104.x-v0.200.x/test_loop.js
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/redux-loop_v2.2.x.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/redux-loop_v2.2.x.js
new file mode 100644
index 0000000000..31d64b7ffd
--- /dev/null
+++ b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/redux-loop_v2.2.x.js
@@ -0,0 +1,91 @@
+declare module "redux-loop" {
+  declare type Effect = $Subtype<{...}>;
+
+  declare type Reducer<S, A> = (state: S, action: A) => S | [S, Effect];
+
+  declare type ExtractStateType = <S, A>(r: (state: S, action: A) => any) => S;
+
+  declare function combineReducers<
+    Reducers: Object,
+    State: $ObjMap<Reducers, ExtractStateType>,
+    Action
+  >(
+    reducersMap: Reducers,
+    initialState?: $Shape<State>,
+    accessor?: (state: State, key: $Keys<State>) => any,
+    modifier?: (state: State, key: $Keys<State>, value: any) => any
+  ): (state: State, action: Action) => [State, Effect];
+
+  declare var Effects: {
+    batch: (effects: Effect[]) => Effect,
+    // Several of the effect constructors here accept a callback with arguments
+    // to apply to the callback. Listing each possible callback argument with
+    // a distinct type variable allows Flow to check that the types of arguments
+    // match up with the signature of the callback. But there are two
+    // limitations:
+    //
+    // - it is only possible to type out a finite number of callback arguments
+    // (I chose a max of five)
+    // - Flow will not report an error if the caller does not supply all of the
+    // arguments that the callback requires
+
+    call: <Action: { type: $Subtype<string>, ... }, A, B, C, D, E>(
+      actionFactory: (a: A, b: B, c: C, d: D, e: E) => Action,
+      a?: A,
+      b?: B,
+      c?: C,
+      d?: D,
+      e?: E
+    ) => Effect,
+    constant: <A: { type: $Subtype<string>, ... }>(action: A) => Effect,
+    // The `lift` constructor takes a callback that is called with given
+    // arguments *and* with an `action` produced by the input `effect`. Keeping
+    // track of whether the `action` is supposed to be the first or last
+    // argument to the callback is something that I expect will trip people up.
+    // (It is the last argument.) It would be nice to be able to catch the
+    // problem during type-checking if the caller guesses wrong.
+    // Unfortunately I do not know how to accomplish that consistently.
+
+    lift: <Action1, Action2: { type: $Subtype<string>, ... }, A, B, C, D, E>(
+      effect: Effect,
+      f: (a: A, b: B, c: C, d: D, e: E, action: Action1) => Action2,
+      a?: A,
+      b?: B,
+      c?: C,
+      d?: D,
+      e?: E
+    ) => Effect,
+    promise: <Action: { type: $Subtype<string>, ... }, A, B, C, D, E>(
+      actionFactory: (a: A, b: B, c: C, d: D, e: E) => Promise<Action>,
+      a?: A,
+      b?: B,
+      c?: C,
+      d?: D,
+      e?: E
+    ) => Effect,
+    none: () => Effect,
+    ...
+  };
+
+  declare function getEffect<S>(loop: [S, Effect]): Effect;
+  declare function getEffect<S>(loop: S): null;
+
+  declare function getModel<S>(loop: [S, Effect] | S): S;
+
+  // TODO: When we are able to import type definitions from other libdefs, this
+  // declaration should be changed to:
+  //
+  //     declare function install<S, A>(): StoreEnhancer<S, A>;
+  //
+  // Where `StoreEnhancer` comes from 'redux'.
+  //
+  // see https://github.com/flowtype/flow-typed/issues/16
+  //
+  declare function install(): Function;
+
+  declare function isLoop<S>(loop: S | [S, Effect]): boolean;
+
+  declare function liftState<S>(state: S | [S, Effect]): [S, Effect];
+
+  declare function loop<S>(state: S, effect: Effect): [S, Effect];
+}
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_combineReducers.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_combineReducers.js
new file mode 100644
index 0000000000..689e631b7e
--- /dev/null
+++ b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_combineReducers.js
@@ -0,0 +1,73 @@
+/* @flow */
+
+import { combineReducers } from "redux-loop";
+
+import type { Effect, Reducer } from "redux-loop";
+
+type StateA = number;
+type StateB = string;
+type StateC = boolean;
+
+type State = {
+  a: StateA,
+  b: StateB,
+  c: StateC,
+  ...
+};
+
+const action = { type: "ACTION" };
+
+function testCombineReducers<Action>(
+  a: Reducer<StateA, Action>,
+  b: (state: StateB, action: Action) => StateB,
+  c: (state: StateC, action: Action) => StateC | [StateC, Effect]
+) {
+  // ok
+  const reducer = combineReducers({ a, b, c }, { a: 1, b: "two", c: false });
+
+  // ok
+  const reducer2: Reducer<State, Action> = combineReducers(
+    { a, b, c },
+    { a: 1, b: "two", c: false }
+  );
+
+  // ok
+  const result: [State, Effect] = reducer({ a: 1, b: "two", c: false }, action);
+
+  //
+  // Checks type of state input to reducer
+  //
+
+  // $FlowExpectedError
+  reducer({}, action);
+
+  // $FlowExpectedError
+  reducer({ a: "badvalue", b: "two", c: false }, action);
+
+  // $FlowExpectedError
+  reducer({ a: 1, b: 2, c: false }, action);
+
+  // $FlowExpectedError
+  reducer({ a: 1, b: "two", c: new Date() }, action);
+
+  //
+  // Checks shape of initial state
+  //
+
+  // TODO: This should fail, but does not. It appears that `$Shape` does not
+  // combine well with `$ObjMap`.
+  //
+  // combineReducers({ a, b, c }, { a: 'one' })
+
+  //
+  // State accessor and modifier
+  //
+
+  // ok
+  combineReducers(
+    { a, b, c },
+    {},
+    (state, key) => state[key],
+    (state, key, value) => (state[key] = value)
+  );
+}
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_effects.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_effects.js
new file mode 100644
index 0000000000..a656ecad55
--- /dev/null
+++ b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_effects.js
@@ -0,0 +1,106 @@
+/* @flow */
+
+import { Effects } from "redux-loop";
+import type { Effect } from "redux-loop";
+
+//
+// Effects.none
+//
+
+// ok
+const none: Effect = Effects.none();
+
+//
+// Effects.constant
+//
+
+// ok
+const constant: Effect = Effects.constant({ type: "foo" });
+
+// $FlowExpectedError
+Effects.constant({ noTypeProp: "foo" });
+
+//
+// Effects.call
+//
+
+function zeroArg() {
+  return { type: "zeroArg" };
+}
+
+function string(x: string) {
+  return { type: "string", x };
+}
+
+function numberString(x: number, y: string) {
+  return { type: "numberString", x, y };
+}
+
+// ok
+const callEffect: Effect = Effects.call(zeroArg);
+
+// ok
+Effects.call(string, "one");
+
+// ok
+Effects.call(numberString, 1, "two");
+
+// $FlowExpectedError
+Effects.call(string, 1);
+
+// $FlowExpectedError
+Effects.call(string, 1);
+
+// ok
+Effects.call(string, "one", "two");
+
+//
+// Effects.promise
+//
+
+function asyncActionCreator(x: string, y: number) {
+  return Promise.resolve({
+    type: "asyncAction",
+    x,
+    y
+  });
+}
+
+// ok
+Effects.promise(asyncActionCreator, "one", 2);
+
+// $FlowExpectedError
+Effects.promise(asyncActionCreator, 1, "two");
+
+//
+// Effects.batch
+//
+
+// ok
+Effects.batch([
+  Effects.call(zeroArg),
+  Effects.promise(asyncActionCreator, "one", 2)
+]);
+
+//
+// Effects.lift
+//
+
+function nestedAction(time: Date, action: { type: $Subtype<string>, ... }) {
+  return { type: "NESTED_ACTION", payload: action, time };
+}
+
+function nestedActionWrongArgOrder(
+  action: { type: $Subtype<string>, ... },
+  time: Date
+) {
+  return { type: "NESTED_ACTION", payload: action, time };
+}
+
+const nestedEffect = Effects.call(zeroArg);
+
+// ok
+Effects.lift(nestedEffect, nestedAction, new Date());
+
+// $FlowExpectedError
+Effects.lift(nestedEffect, nestedActionWrongArgOrder, new Date());
diff --git a/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_loop.js b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_loop.js
new file mode 100644
index 0000000000..8f0d61c965
--- /dev/null
+++ b/definitions/npm/redux-loop_v2.2.x/flow_v0.201.x-/test_loop.js
@@ -0,0 +1,75 @@
+/* @flow */
+
+import { loop, Effects } from "redux-loop";
+import * as L from "redux-loop";
+
+import type { Effect, Reducer } from "redux-loop";
+
+//
+// loop, Reducer
+//
+
+type State = {
+  first: boolean,
+  second: boolean,
+  ...
+};
+
+type Action = { type: "FIRST", ... } | { type: "SECOND", ... };
+
+// ok
+const reducer: Reducer<State, Action> = (state: State, action) => {
+  switch (action.type) {
+    case "FIRST":
+      return loop(
+        { ...state, first: true },
+        Effects.constant({ type: "SECOND" })
+      );
+
+    case "SECOND":
+      return { ...state, second: true };
+
+    default:
+      // $FlowExpectedError
+      return {};
+  }
+};
+
+//
+// liftState
+//
+
+// ok
+const lifted: [State, Effect] = L.liftState({ first: true, second: false });
+
+//
+// loop accessors
+//
+
+const state: State = { first: true, second: false };
+
+const loopState: [State, Effect] = loop(
+  { first: true, second: false },
+  Effects.constant({ type: "SECOND" })
+);
+
+// ok
+const model1: State = L.getModel(loopState);
+
+// ok
+const model2: State = L.getModel(state);
+
+// ok
+const effect1: Effect = L.getEffect(loopState);
+
+// ok
+const effect2: null = L.getEffect(state);
+
+// $FlowExpectedError
+const effect3: Effect = L.getEffect(state);
+
+// ok
+L.isLoop(loopState);
+
+// ok
+L.isLoop(state);
diff --git a/definitions/npm/remarkable_v1.x.x/flow_v0.104.x-/remarkable_v1.x.x.js b/definitions/npm/remarkable_v1.x.x/flow_v0.104.x-v0.200.x/remarkable_v1.x.x.js
similarity index 100%
rename from definitions/npm/remarkable_v1.x.x/flow_v0.104.x-/remarkable_v1.x.x.js
rename to definitions/npm/remarkable_v1.x.x/flow_v0.104.x-v0.200.x/remarkable_v1.x.x.js
diff --git a/definitions/npm/remarkable_v1.x.x/flow_v0.201.x-/remarkable_v1.x.x.js b/definitions/npm/remarkable_v1.x.x/flow_v0.201.x-/remarkable_v1.x.x.js
new file mode 100644
index 0000000000..debe2e8d3d
--- /dev/null
+++ b/definitions/npm/remarkable_v1.x.x/flow_v0.201.x-/remarkable_v1.x.x.js
@@ -0,0 +1,73 @@
+declare module 'remarkable' {
+  declare type Env = any;
+
+  declare type Token = any;
+
+  declare type State = any;
+
+  declare type RemarkablePlugin<Option> = (md: Remarkable, option: Option) => void;
+
+  declare export type RemarkableOptions = {
+    // Enable HTML tags in source
+    html: boolean,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: boolean,
+    // Convert '\n' in paragraphs into <br>
+    breaks: boolean,
+    // CSS language prefix for fenced blocks
+    langPrefix: string,
+    // Autoconvert URL-like text to links
+    linkify: boolean,
+    // Enable some language-neutral replacement + quotes beautification
+    typographer: boolean,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.
+    quotes: string,
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed
+    highlight: (str: string, lang: string) => string,
+    ...
+  };
+
+  declare type RemarkableSettings = 'default' | 'commonmark' | 'full' | $Shape<RemarkableOptions>;
+
+  declare type Parser = {
+    ruler: Ruler,
+    parse(str: string, options: RemarkableOptions, env: Env, outTokens: Array<Token>): void,
+    ...
+  }
+
+  declare type RuleFunction = (state: State, silent: boolean) => boolean;
+
+  declare class Ruler {
+    at(name: string, fn: RuleFunction, options: RemarkableOptions): void;
+    before(beforeName: string, ruleName: string, fn: RuleFunction, options: RemarkableOptions): void;
+    after(afterName: string, ruleName: string, fn: RuleFunction, options: RemarkableOptions): void;
+    push(ruleName: string, fn: RuleFunction, options: RemarkableOptions): void;
+    enable(list: string | Array<string>, strict: boolean): void;
+    disable(list: string | Array<string>): void;
+    getRules(chaineName: string): Array<RuleFunction>;
+  }
+
+  declare class Renderer {
+    render(tokens: Array<Token>, options: RemarkableOptions, env: Env): string;
+    renderInline(tokens: Array<Token>, options: RemarkableOptions, env: Env): string;
+  }
+
+  declare class Remarkable {
+    constructor(settings?: RemarkableSettings): void;
+    use<Option>(plugin: RemarkablePlugin<Option>, options?: Option): this;
+    parse(source: string, env?: Env): Array<Token>;
+    parseInline(source: string, env?: any): Array<Token>;
+    set(settings: RemarkableSettings): void;
+    render(source: string, env?: Env): string;
+    renderInline(source: string, env?: Env): string;
+    //parsers
+    inline: Parser;
+    block: Parser;
+    core: Parser;
+    renderer: Renderer;
+  }
+
+  declare export default typeof Remarkable;
+}
diff --git a/definitions/npm/remarkable_v2.x.x/flow_v0.104.x-/remarkable_v2.x.x.js b/definitions/npm/remarkable_v2.x.x/flow_v0.104.x-v0.200.x/remarkable_v2.x.x.js
similarity index 100%
rename from definitions/npm/remarkable_v2.x.x/flow_v0.104.x-/remarkable_v2.x.x.js
rename to definitions/npm/remarkable_v2.x.x/flow_v0.104.x-v0.200.x/remarkable_v2.x.x.js
diff --git a/definitions/npm/remarkable_v2.x.x/flow_v0.201.x-/remarkable_v2.x.x.js b/definitions/npm/remarkable_v2.x.x/flow_v0.201.x-/remarkable_v2.x.x.js
new file mode 100644
index 0000000000..d4e55a4219
--- /dev/null
+++ b/definitions/npm/remarkable_v2.x.x/flow_v0.201.x-/remarkable_v2.x.x.js
@@ -0,0 +1,116 @@
+declare module 'remarkable' {
+  declare type Env = any;
+
+  declare type Token = any;
+
+  declare type State = any;
+
+  declare export type RemarkablePlugin<Option> = (
+    md: Remarkable,
+    option: Option
+  ) => void;
+
+  declare export type RemarkableOptions = {
+    // Enable HTML tags in source
+    html: boolean,
+    // Use '/' to close single tags (<br />)
+    xhtmlOut: boolean,
+    // Convert '\n' in paragraphs into <br>
+    breaks: boolean,
+    // CSS language prefix for fenced blocks
+    langPrefix: string,
+    // Enable some language-neutral replacement + quotes beautification
+    typographer: boolean,
+    // Double + single quotes replacement pairs, when typographer enabled,
+    // and smartquotes on. Set doubles to '«»' for Russian, '„“' for German.
+    quotes: string,
+    // Set target to open link in
+    linkTarget: string,
+    // Highlighter function. Should return escaped HTML,
+    // or '' if the source string is not changed
+    highlight: (str: string, lang: string) => string,
+    ...
+  };
+
+  declare type RemarkableSettings =
+    | 'default'
+    | 'commonmark'
+    | 'full'
+    | $Shape<RemarkableOptions>;
+
+  declare type Parser = {
+    ruler: Ruler,
+    parse(
+      str: string,
+      options: RemarkableOptions,
+      env: Env,
+      outTokens: Array<Token>
+    ): void,
+    ...
+  };
+
+  declare type RuleFunction = (state: State, silent: boolean) => boolean;
+
+  declare class Ruler {
+    at(name: string, fn: RuleFunction, options: RemarkableOptions): void;
+    before(
+      beforeName: string,
+      ruleName: string,
+      fn: RuleFunction,
+      options: RemarkableOptions
+    ): void;
+    after(
+      afterName: string,
+      ruleName: string,
+      fn: RuleFunction,
+      options: RemarkableOptions
+    ): void;
+    push(ruleName: string, fn: RuleFunction, options: RemarkableOptions): void;
+    enable(list: string | Array<string>, strict: boolean): void;
+    disable(list: string | Array<string>): void;
+    getRules(chaineName: string): Array<RuleFunction>;
+  }
+
+  declare class Renderer {
+    render(tokens: Array<Token>, options: RemarkableOptions, env: Env): string;
+    renderInline(
+      tokens: Array<Token>,
+      options: RemarkableOptions,
+      env: Env
+    ): string;
+  }
+
+  declare export class Remarkable {
+    constructor(settings?: RemarkableSettings): void;
+    use<Option>(plugin: RemarkablePlugin<Option>, options?: Option): this;
+    parse(source: string, env?: Env): Array<Token>;
+    parseInline(source: string, env?: any): Array<Token>;
+    set(settings: RemarkableSettings): void;
+    render(source: string, env?: Env): string;
+    renderInline(source: string, env?: Env): string;
+    // parsers
+    inline: Parser;
+    block: Parser;
+    core: Parser;
+    renderer: Renderer;
+  }
+
+  declare type Utils = {|
+    isString(obj?: any): boolean,
+    has(object: any, key: string): boolean,
+    assign(target: any, ...sources: any[]): any,
+    unescapeMd(str: string): string,
+    isValidEntityCode(c: number): boolean,
+    fromCodePoint(c: number): string,
+    replaceEntities(str: string): string,
+    escapeHtml(str: string): string,
+  |};
+
+  declare export var utils: Utils;
+}
+
+declare module 'remarkable/linkify' {
+  import type { RemarkablePlugin } from 'remarkable';
+
+  declare export var linkify: RemarkablePlugin<void>;
+}
diff --git a/definitions/npm/rethinkdb_v2.x.x/flow_v0.104.x-/rethinkdb_v2.x.x.js b/definitions/npm/rethinkdb_v2.x.x/flow_v0.104.x-v0.200.x/rethinkdb_v2.x.x.js
similarity index 100%
rename from definitions/npm/rethinkdb_v2.x.x/flow_v0.104.x-/rethinkdb_v2.x.x.js
rename to definitions/npm/rethinkdb_v2.x.x/flow_v0.104.x-v0.200.x/rethinkdb_v2.x.x.js
diff --git a/definitions/npm/rethinkdb_v2.x.x/flow_v0.201.x-/rethinkdb_v2.x.x.js b/definitions/npm/rethinkdb_v2.x.x/flow_v0.201.x-/rethinkdb_v2.x.x.js
new file mode 100644
index 0000000000..c9dc52f1e5
--- /dev/null
+++ b/definitions/npm/rethinkdb_v2.x.x/flow_v0.201.x-/rethinkdb_v2.x.x.js
@@ -0,0 +1,208 @@
+declare module "rethinkdb" {
+
+  declare export class Connection {}
+
+  declare class Op<T> {
+    branch<TTrue, TFalse> (trueAction: Op<TTrue> | TTrue, falseAction: Op<TFalse> | TFalse): Op<TTrue | TFalse>;
+
+    run (conn: Connection): Promise<T>;
+  }
+
+  declare class ErrorControlStructure {}
+
+  declare type Predicate<T> = $Shape<T> | T => mixed;
+
+  declare type SliceOptions = {|
+    leftBound?: 'open' | 'closed',
+    rightBound?: 'open' | 'closed'
+  |}
+
+  declare class Cursor<T> {
+    toArray (): Promise<T[]>;
+  }
+
+  declare class SequenceOp<T> {
+    contains (value: T | Predicate<T>): Op<bool>;
+
+    filter (Predicate<T>, options?: { default: boolean | ErrorControlStructure, ... }): SequenceOp<T>;
+
+    slice (startOffset: number, options?: SliceOptions): SequenceOp<T>;
+
+    slice (startOffset: number, endOffset: number, options?: SliceOptions): SequenceOp<T>;
+
+    count (filter?: T | Predicate<T>): Op<number>;
+
+    getField<TProperty> (key: $Keys<T>): SequenceOp<TProperty>;
+
+    eqJoin<TRDoc> (leftField: $Keys<T>, rightTable: TableOp<TRDoc, any, any>): SequenceOp<{| left: T, right: TRDoc |}>;
+
+    eqJoin<TRDoc> (func: T => mixed, rightTable: TableOp<TRDoc, any, any>): SequenceOp<{| left: T, right: TRDoc |}>;
+
+    run (conn: Connection): Promise<Cursor<T>>;
+
+  }
+
+  declare type ConflictResolutionFunc<TPrimaryKey, TDoc> = ((id: TPrimaryKey, oldDoc: TDoc, newDoc: TDoc) => TDoc);
+
+  declare type Durability = 'soft' | 'hard';
+
+  declare type Change<TNewVal, TOldVal> = {| new_val: TNewVal, old_val: TOldVal |}
+
+  declare type ChangeSet<TNewVal, TOldVal> = Array<Change<TNewVal, TOldVal>>
+
+  declare type InsertOptions<TPrimaryKey, TDoc> = {|
+    durability?: Durability,
+    returnChanges?: false,
+    conflict?: 'error' | 'replace' | 'update' | ConflictResolutionFunc<TPrimaryKey, TDoc>
+  |};
+
+  declare type InsertOptionsWithChanges<TPrimaryKey, TDoc> = {|
+    durability?: Durability,
+    returnChanges: true | 'always',
+    conflict?: 'error' | 'replace' | 'update' | ConflictResolutionFunc<TPrimaryKey, TDoc>
+  |};
+
+  declare type InsertResult = {|
+    inserted: number,
+    replaced: number,
+    unchanged: number,
+    errors: number,
+    deleted: 0,
+    skipped: 0,
+    first_error?: string,
+    generated_keys?: string[],
+    warnings?: string,
+  |};
+
+  declare type InsertResultWithChanges<TDoc> = {|
+    ...InsertResult,
+    changes: ChangeSet<TDoc, null>
+  |};
+
+  declare export class TableOp<TDoc, TPrimaryKey, TInsertDoc=TDoc> extends SequenceOp<TDoc> {
+    insert (obj: (TInsertDoc | TInsertDoc[] | TDoc | TDoc[]), options?: InsertOptions<TPrimaryKey, TDoc>): Op<InsertResult>;
+
+    insert (obj: (TInsertDoc | TInsertDoc[] | TDoc | TDoc[]), options: InsertOptionsWithChanges<TPrimaryKey, TDoc>): Op<InsertResultWithChanges<TDoc>>;
+
+    get (key: TPrimaryKey): SingleRowSelectionOp<TDoc>;
+
+  }
+
+  declare type TableConfig = {||};
+  declare type DatabaseConfig = {||};
+
+  declare type TableCreateOptions = {|
+    primaryKey?: string,
+    durability?: Durability,
+    shards?: number,
+    replicas?: number | { [string]: number, ... },
+    primaryReplicaTag?: string
+  |};
+
+  declare type SSLOptions = {|
+    ca: Array<Buffer>
+  |}
+
+  declare type ConnectOptions = {|
+    host?: string,
+    port?: string,
+    db?: string,
+    user?: string,
+    password?: string,
+    timeout?: string,
+    ssl?: ?SSLOptions
+  |}
+
+  declare type DeleteOptions = {|
+    durability?: Durability,
+    returnChanges?: false
+  |};
+
+  declare type DeleteOptionsWithChanges = {|
+    durability?: Durability,
+    returnChanges: true | 'always'
+  |};
+
+  declare type DeleteResult = {|
+    deleted: number,
+    skipped: number,
+    errors: number,
+    first_error?: string,
+    inserted: 0,
+    replaced: 0,
+    unchanged: 0
+  |};
+
+  declare type DeleteResultWithChanges<TDoc> = {|
+    ...DeleteResult,
+    changes: ChangeSet<null, TDoc>
+  |};
+
+  declare type UpdateOptions = {|
+    durability?: Durability,
+    nonAtomic?: boolean,
+    returnChanges?: false
+  |};
+
+  declare type UpdateOptionsWithChanges = {|
+    durability?: Durability,
+    nonAtomic?: boolean,
+    returnChanges: true | 'always'
+  |};
+
+  declare type UpdateResult = {|
+    deleted: 0,
+    skipped: number,
+    errors: number,
+    first_error?: string,
+    inserted: 0,
+    replaced: number,
+    unchanged: number
+  |};
+
+  declare type UpdateResultWithChanges<TDoc> = {|
+    ...UpdateResult,
+    changes: ChangeSet<TDoc, TDoc>
+  |};
+
+  declare class SingleRowSelectionOp<TDoc> extends Op<?TDoc> {
+    delete (options?: DeleteOptions): Op<DeleteResult>;
+
+    delete (options: DeleteOptionsWithChanges): Op<DeleteResultWithChanges<TDoc>>;
+
+    update (object: $Shape<TDoc>): Op<UpdateResult>;
+
+    update (object: $Shape<TDoc>, options: UpdateOptions): Op<UpdateResult>;
+
+    update (object: $Shape<TDoc>, options: UpdateOptionsWithChanges): Op<UpdateResultWithChanges<TDoc>>;
+  }
+
+  declare class R {
+    tableCreate (tableName: string, options?: TableCreateOptions): Op<{
+      tables_created: 1,
+      config_changes: ChangeSet<TableConfig, null>,
+      ...
+    }>;
+    dbList (): SequenceOp<string>;
+    tableList (): Op<string[]>;
+    branch<TTest, TTrue, TFalse> (test: Op<TTest>, trueAction: Op<TTrue> | TTrue, falseAction: Op<TFalse> | TFalse): Op<TTrue | TFalse>;
+    connect (options?: ConnectOptions | string): Promise<Connection>;
+    dbCreate (dbName: string): Op<{
+      dbs_created: 1,
+      config_changes: [{
+        old_val: null,
+        new_val: DatabaseConfig,
+        ...
+      }],
+      ...
+    }>;
+    table (tableName: string, options?: {
+      readMode?: 'single' | 'majority' | 'outdated',
+      identifierFormat?: 'name' | 'uuid',
+      ...
+    }): TableOp<any, any, any>;
+    error (): ErrorControlStructure;
+  }
+
+  declare export default R
+}
diff --git a/definitions/npm/sanitize-html_v1.x.x/flow_v0.104.x-/sanitize-html_v1.x.x.js b/definitions/npm/sanitize-html_v1.x.x/flow_v0.104.x-v0.200.x/sanitize-html_v1.x.x.js
similarity index 100%
rename from definitions/npm/sanitize-html_v1.x.x/flow_v0.104.x-/sanitize-html_v1.x.x.js
rename to definitions/npm/sanitize-html_v1.x.x/flow_v0.104.x-v0.200.x/sanitize-html_v1.x.x.js
diff --git a/definitions/npm/sanitize-html_v1.x.x/flow_v0.201.x-/sanitize-html_v1.x.x.js b/definitions/npm/sanitize-html_v1.x.x/flow_v0.201.x-/sanitize-html_v1.x.x.js
new file mode 100644
index 0000000000..40b2c3af2c
--- /dev/null
+++ b/definitions/npm/sanitize-html_v1.x.x/flow_v0.201.x-/sanitize-html_v1.x.x.js
@@ -0,0 +1,38 @@
+declare module "sanitize-html" {
+  declare type Frame = {
+    tag: string,
+    attribs: Object,
+    text: string,
+    tagPosition: number,
+    ...
+  };
+  declare type SanitizeOptions = {
+    allowedTags?: Array<string> | false,
+    allowedAttributes?: { [key: string]: Array<string>, ... }[] | Object | false,
+    transformTags?: { [key: string]:
+      | string
+      | ((
+          tagName: string,
+          attribs: Object
+        ) => {
+      tagName: string,
+      attribs: Object,
+      ...
+    }), ... },
+    exclusiveFilter?: (frame: Frame) => boolean,
+    textFilter?: (text: string) => string,
+    allowedClasses?: { [key: string]: Array<string>, ... },
+    allowedSchemes?: Array<string> | { [key: string]: Array<string>, ... },
+    nonTextTags?: Array<string>,
+    parser?: $Shape<{
+      xmlMode: boolean,
+      lowerCaseTags: boolean,
+      lowerCaseAttributeNames: boolean,
+      recognizeCDATA: boolean,
+      recognizeSelfClosing: boolean,
+      ...
+    }>,
+    ...
+  };
+  declare module.exports: (dirty: string, options?: SanitizeOptions) => string;
+}
diff --git a/definitions/npm/sequelize_v4.x.x/flow_v0.104.x-/sequelize_v4.x.x.js b/definitions/npm/sequelize_v4.x.x/flow_v0.104.x-v0.200.x/sequelize_v4.x.x.js
similarity index 100%
rename from definitions/npm/sequelize_v4.x.x/flow_v0.104.x-/sequelize_v4.x.x.js
rename to definitions/npm/sequelize_v4.x.x/flow_v0.104.x-v0.200.x/sequelize_v4.x.x.js
diff --git a/definitions/npm/sequelize_v4.x.x/flow_v0.104.x-/test_sequelize.js b/definitions/npm/sequelize_v4.x.x/flow_v0.104.x-v0.200.x/test_sequelize.js
similarity index 100%
rename from definitions/npm/sequelize_v4.x.x/flow_v0.104.x-/test_sequelize.js
rename to definitions/npm/sequelize_v4.x.x/flow_v0.104.x-v0.200.x/test_sequelize.js
diff --git a/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/sequelize_v4.x.x.js b/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/sequelize_v4.x.x.js
new file mode 100644
index 0000000000..279eba811d
--- /dev/null
+++ b/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/sequelize_v4.x.x.js
@@ -0,0 +1,7109 @@
+// @flow
+
+declare module "sequelize" {
+  /**
+   * The options for the getAssociation mixin of the belongsTo association.
+   * @see  BelongsToGetOne
+   */
+  declare export type BelongsToGetOneOptions = { /**
+   * Apply a scope on the related model, or remove its default scope by passing false.
+   */
+  scope?: ?(string | boolean), ... }
+
+
+  /**
+   * The getAssociation mixin applied to models with belongsTo.
+   * An example of usage is as follows
+
+  ```js
+
+  User.belongsTo(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttrib>, UserAttrib {
+    getRole: BelongsToGetOne<RoleInstance>;
+    // setRole...
+    // createRole...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to/
+   * @see  Model
+  */
+  declare export type BelongsToGetOne<TInstance: Model<any>> = { /**
+   * Get the associated instance.
+   * @param options The options to use when getting the association.
+   */
+  (options?: BelongsToGetOneOptions): Promise<?TInstance>, ... }
+
+
+  /**
+   * The options for the setAssociation mixin of the belongsTo association.
+   * @see  BelongsToSetOne
+   */
+  declare export type BelongsToSetOneOptions = { /**
+   * Skip saving this after setting the foreign key if false.
+   */
+  save?: boolean, ... }
+
+
+  /**
+   * The setAssociation mixin applied to models with belongsTo.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsTo(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRole...
+    setRole: BelongsToSetOne<RoleInstance, RoleId>;
+    // createRole...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to/
+   * @see  Model
+  */
+  declare export type BelongsToSetOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Set the associated instance.
+   * @param newAssociation An instance or the primary key of an instance to associate with this. Pass null or undefined to remove the association.
+   * @param options the options passed to `this.save`.
+   */
+  (newAssociation: ?(TInstance | TInstancePrimaryKey), options?: BelongsToSetOneOptions & InstanceSaveOptions<any>): Promise<void>, ... }
+
+  /**
+   * The options for the createAssociation mixin of the belongsTo association.
+   * @see  BelongsToCreateOne
+   */
+  declare export type BelongsToCreateOneOptions = {...}
+
+
+  /**
+   * The createAssociation mixin applied to models with belongsTo.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsTo(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRole...
+    // setRole...
+    createRole: BelongsToCreateOne<RoleAttributes>;
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to/
+   * @see  Model
+  */
+  declare export type BelongsToCreateOne<TInitAttributes> = { /**
+   * Create a new instance of the associated model and associate it with this.
+   * @param values The values used to create the association.
+   * @param options The options passed to `target.create` and `setAssociation`.
+   */
+  (values?: TInitAttributes, options?: BelongsToCreateOneOptions & CreateOptions<any> & BelongsToSetOneOptions): Promise<void>, ... }
+
+
+  /**
+   * The options for the getAssociation mixin of the hasOne association.
+   * @see  HasOneGetOne
+   */
+  declare export type HasOneGetOneOptions = { /**
+   * Apply a scope on the related model, or remove its default scope by passing false.
+   */
+  scope?: ?(string | boolean), ... }
+
+
+  /**
+   * The getAssociation mixin applied to models with hasOne.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasOne(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttrib>, UserAttrib {
+    getRole: HasOneGetOne<RoleInstance>;
+    // setRole...
+    // createRole...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-one/
+   * @see  Model
+  */
+  declare export type HasOneGetOne<TInstance: Model<any>> = { /**
+   * Get the associated instance.
+   * @param options The options to use when getting the association.
+   */
+  (options?: HasOneGetOneOptions): Promise<?TInstance>, ... }
+
+
+  /**
+   * The options for the setAssociation mixin of the hasOne association.
+   * @see  HasOneSetOne
+   */
+  declare export type HasOneSetOneOptions = { /**
+   * Skip saving this after setting the foreign key if false.
+   */
+  save?: boolean, ... }
+
+
+  /**
+   * The setAssociation mixin applied to models with hasOne.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasOne(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRole...
+    setRole: HasOneSetOne<RoleInstance, RoleId>;
+    // createRole...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-one/
+   * @see  Model
+  */
+  declare export type HasOneSetOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Set the associated instance.
+   * @param newAssociation An instance or the primary key of an instance to associate with this. Pass null or undefined to remove the association.
+   * @param options The options passed to `getAssocation` and `target.save`.
+   */
+  (newAssociation: ?(TInstance | TInstancePrimaryKey), options?: HasOneSetOneOptions & HasOneGetOneOptions & InstanceSaveOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the createAssociation mixin of the hasOne association.
+   * @see  HasOneCreateOne
+   */
+  declare export type HasOneCreateOneOptions = {...}
+
+
+  /**
+   * The createAssociation mixin applied to models with hasOne.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasOne(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRole...
+    // setRole...
+    createRole: HasOneCreateOne<RoleAttributes>;
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-one/
+   * @see  Model
+  */
+  declare export type HasOneCreateOne<TInitAttributes> = { /**
+   * Create a new instance of the associated model and associate it with this.
+   * @param values The values used to create the association.
+   * @param options The options passed to `target.create` and `setAssociation`.
+   */
+  (values?: TInitAttributes, options?: HasOneCreateOneOptions & HasOneSetOneOptions & CreateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the getAssociations mixin of the hasMany association.
+   * @see  HasManyGetMany
+   */
+  declare export type HasManyGetManyOptions = {
+   /**
+    * An optional where clause to limit the associated models.
+    */
+   where?: WhereOptions,
+   /**
+    * Apply a scope on the related model, or remove its default scope by passing false.
+    */
+   scope?: ?(string | boolean),
+   ...
+  }
+
+
+  /**
+   * The getAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    getRoles: HasManyGetMany<RoleInstance>;
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyGetMany<TInstance: Model<any>> = { /**
+   * Get everything currently associated with this, using an optional where clause.
+   * @param options The options to use when getting the associations.
+   */
+  (options?: HasManyGetManyOptions): Promise<TInstance[]>, ... }
+
+
+  /**
+   * The options for the setAssociations mixin of the hasMany association.
+   * @see  HasManySetMany
+   */
+  declare export type HasManySetManyOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The setAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    setRoles: HasManySetMany<RoleInstance, RoleId>;
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManySetMany<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Set the associated models by passing an array of instances or their primary keys.
+   * Everything that it not in the passed array will be un-associated.
+   * @param newAssociations An array of instances or primary key of instances to associate with this. Pass null or undefined to remove all associations.
+   * @param options The options passed to `target.findAll` and `update`.
+   */
+  (newAssociations: ?$ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: HasManySetManyOptions & AnyFindOptions & InstanceUpdateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the addAssociations mixin of the hasMany association.
+   * @see  HasManyAddMany
+   */
+  declare export type HasManyAddManyOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The addAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    addRoles: HasManyAddMany<RoleInstance, RoleId>;
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyAddMany<TInstance: Model<any>, TInstancePrimaryKey> ={ /**
+   * Associate several instances with this.
+   * @param newAssociations An array of instances or primary key of instances to associate with this.
+   * @param options The options passed to `target.update`.
+   */
+  (newAssociations: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: HasManyAddManyOptions & InstanceUpdateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the addAssociation mixin of the hasMany association.
+   * @see  HasManyAddOne
+   */
+  declare export type HasManyAddOneOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The addAssociation mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    addRole: HasManyAddOne<RoleInstance, RoleId>;
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyAddOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Associate an instance with this.
+   * @param newAssociation An instance or the primary key of an instance to associate with this.
+   * @param options The options passed to `target.update`.
+   */
+  (newAssociation: TInstance | TInstancePrimaryKey, options?: HasManyAddOneOptions & InstanceUpdateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the createAssociation mixin of the hasMany association.
+   * @see  HasManyCreateOne
+   */
+  declare export type HasManyCreateOneOptions = {...}
+
+
+  /**
+   * The createAssociation mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    createRole: HasManyCreateOne<RoleAttributes>;
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyCreateOne<TInitAttributes, TInstance: Model<any, TInitAttributes>> = { /**
+   * Create a new instance of the associated model and associate it with this.
+   * @param values The values used to create the association.
+   * @param options The options to use when creating the association.
+   */
+  (values?: TInitAttributes, options?: HasManyCreateOneOptions & CreateOptions<any>): Promise<TInstance>, ... }
+
+
+  /**
+   * The options for the removeAssociation mixin of the hasMany association.
+   * @see  HasManyRemoveOne
+   */
+  declare export type HasManyRemoveOneOptions = {...}
+
+
+  /**
+   * The removeAssociation mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    removeRole: HasManyRemoveOne<RoleInstance, RoleId>;
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyRemoveOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Un-associate the instance.
+   * @param oldAssociated The instance or the primary key of the instance to un-associate.
+   * @param options The options passed to `target.update`.
+   */
+  (oldAssociated: TInstance | TInstancePrimaryKey, options?: HasManyRemoveOneOptions & InstanceUpdateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the removeAssociations mixin of the hasMany association.
+   * @see  HasManyRemoveMany
+   */
+  declare export type HasManyRemoveManyOptions = {...}
+
+
+  /**
+   * The removeAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    removeRoles: HasManyRemoveMany<RoleInstance, RoleId>;
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyRemoveMany<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Un-associate several instances.
+   * @param oldAssociated An array of instances or primary key of instances to un-associate.
+   * @param options The options passed to `target.update`.
+   */
+  (oldAssociateds?: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: HasManyRemoveManyOptions & InstanceUpdateOptions<any>): Promise<void>, ... }
+
+
+  /**
+   * The options for the hasAssociation mixin of the hasMany association.
+   * @see  HasManyHasOne
+   */
+  declare export type HasManyHasOneOptions = {...}
+
+
+  /**
+   * The hasAssociation mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    hasRole: HasManyHasOne<RoleInstance, RoleId>;
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyHasOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Check if an instance is associated with this.
+   * @param target The instance or the primary key of the instance to check.
+   * @param options The options passed to `getAssociations`.
+   */
+  (target: TInstance | TInstancePrimaryKey, options?: HasManyHasOneOptions & HasManyGetManyOptions): Promise<boolean>, ... }
+
+
+  /**
+   * The options for the hasAssociations mixin of the hasMany association.
+   * @see  HasManyHasMany
+   */
+  declare export type HasManyHasManyOptions = {...}
+
+
+  /**
+   * The removeAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles
+    // hasRole...
+    hasRoles: HasManyHasMany<RoleInstance, RoleId>;
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyHasMany<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Check if all instances are associated with this.
+   * @param targets An array of instances or primary key of instances to check.
+   * @param options The options passed to `getAssociations`.
+   */
+  (targets: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: HasManyHasManyOptions & HasManyGetManyOptions): Promise<boolean>, ... }
+
+
+  /**
+   * The options for the countAssociations mixin of the hasMany association.
+   * @see  HasManyCount
+   */
+  declare export type HasManyCountOptions = {
+   /**
+    * An optional where clause to limit the associated models.
+    */
+   where?: WhereOptions,
+   /**
+    * Apply a scope on the related model, or remove its default scope by passing false.
+    */
+   scope?: ?(string | boolean),
+   ...
+  }
+
+
+  /**
+   * The countAssociations mixin applied to models with hasMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.hasMany(Role);
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    countRoles: HasManyCount;
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/has-many/
+   * @see  Model
+  */
+  declare export type HasManyCount = { /**
+   * Count everything currently associated with this, using an optional where clause.
+   * @param options The options to use when counting the associations.
+   */
+  (options?: HasManyCountOptions): Promise<number>, ... }
+
+
+  /**
+   * The options for the getAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManyGetMany
+   */
+  declare export type BelongsToManyGetManyOptions = {
+   /**
+    * An optional where clause to limit the associated models.
+    */
+   where?: WhereOptions,
+   /**
+    * Apply a scope on the related model, or remove its default scope by passing false.
+    */
+   scope?: ?(string | boolean),
+   ...
+  }
+
+
+  /**
+   * The getAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    getRoles: BelongsToManyGetMany<RoleInstance>;
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyGetMany<TInstance: Model<any>> = { /**
+   * Get everything currently associated with this, using an optional where clause.
+   * @param options The options to use when getting the associations.
+   */
+  (options?: BelongsToManyGetManyOptions): Promise<TInstance[]>, ... }
+
+
+  /**
+   * The options for the setAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManySetMany
+   */
+  declare export type BelongsToManySetManyOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The setAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    setRoles: BelongsToManySetMany<RoleInstance, RoleId, UserRoleAttributes>;
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManySetMany<TInstance: Model<any>, TInstancePrimaryKey, TJoinTableAttributes> = { /**
+   * Set the associated models by passing an array of instances or their primary keys.
+   * Everything that it not in the passed array will be un-associated.
+   * @param newAssociations An array of instances or primary key of instances to associate with this. Pass null or undefined to remove all associations.
+   * @param options The options passed to `through.findAll`, `bulkCreate`, `update` and `destroy`. Can also hold additional attributes for the join table.
+   */
+  (newAssociations: ?($ReadOnlyArray<TInstance | TInstancePrimaryKey>), options?: BelongsToManySetManyOptions &
+    AnyFindOptions &
+    BulkCreateOptions<any> &
+    InstanceUpdateOptions<any> &
+    InstanceDestroyOptions &
+    { through?: TJoinTableAttributes, ... }): Promise<void>, ... }
+
+
+  /**
+   * The options for the addAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManyAddMany
+   */
+  declare export type BelongsToManyAddManyOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The addAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    addRoles: BelongsToManyAddMany<RoleInstance, RoleId, UserRoleAttributes>;
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyAddMany<TInstance: Model<any>, TInstancePrimaryKey, TJoinTableAttributes> = { /**
+   * Associate several instances with this.
+   * @param newAssociations An array of instances or primary key of instances to associate with this.
+   * @param options The options passed to `through.findAll`, `bulkCreate`, `update` and `destroy`. Can also hold additional attributes for the join table.
+   */
+  (newAssociations: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: BelongsToManyAddManyOptions &
+    AnyFindOptions &
+    BulkCreateOptions<any> &
+    InstanceUpdateOptions<any> &
+    InstanceDestroyOptions &
+    { through?: TJoinTableAttributes, ... }): Promise<void>, ... }
+
+
+  /**
+   * The options for the addAssociation mixin of the belongsToMany association.
+   * @see  BelongsToManyAddOne
+   */
+  declare export type BelongsToManyAddOneOptions = { /**
+   * Run validation for the join model.
+   */
+  validate?: boolean, ... }
+
+
+  /**
+   * The addAssociation mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    addRole: BelongsToManyAddOne<RoleInstance, RoleId, UserRoleAttributes>;
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyAddOne<TInstance: Model<any>, TInstancePrimaryKey, TJoinTableAttributes> = { /**
+   * Associate an instance with this.
+   * @param newAssociation An instance or the primary key of an instance to associate with this.
+   * @param options The options passed to `through.findAll`, `bulkCreate`, `update` and `destroy`. Can also hold additional attributes for the join table.
+   */
+  (newAssociation: TInstance | TInstancePrimaryKey, options?: BelongsToManyAddOneOptions &
+    AnyFindOptions &
+    BulkCreateOptions<any> &
+    InstanceUpdateOptions<any> &
+    InstanceDestroyOptions &
+    { through?: TJoinTableAttributes, ... }): Promise<void>, ... }
+
+
+  /**
+   * The options for the createAssociation mixin of the belongsToMany association.
+   * @see  BelongsToManyCreateOne
+   */
+  declare export type BelongsToManyCreateOneOptions = {...}
+
+
+  /**
+   * The createAssociation mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    createRole: BelongsToManyCreateOne<RoleAttributes, UserRoleAttributes>;
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyCreateOne<TInitAttributes, TInstance: Model<any, TInitAttributes>, TJoinTableAttributes> = { /**
+   * Create a new instance of the associated model and associate it with this.
+   * @param values The values used to create the association.
+   * @param options Options passed to `create` and `add`. Can also hold additional attributes for the join table.
+   */
+  (values?: TInitAttributes, options?: BelongsToManyCreateOneOptions & CreateOptions<any> & { through?: TJoinTableAttributes, ... }): Promise<TInstance>, ... }
+
+
+  /**
+   * The options for the removeAssociation mixin of the belongsToMany association.
+   * @see  BelongsToManyRemoveOne
+   */
+  declare export type BelongsToManyRemoveOneOptions = {...}
+
+
+  /**
+   * The removeAssociation mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    removeRole: BelongsToManyRemoveOne<RoleInstance, RoleId>;
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyRemoveOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Un-associate the instance.
+   * @param oldAssociated The instance or the primary key of the instance to un-associate.
+   * @param options The options passed to `through.destroy`.
+   */
+  (oldAssociated: TInstance | TInstancePrimaryKey, options?: BelongsToManyRemoveOneOptions & InstanceDestroyOptions): Promise<void>, ... }
+
+
+  /**
+   * The options for the removeAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManyRemoveMany
+   */
+  declare export type BelongsToManyRemoveManyOptions = {...}
+
+
+  /**
+   * The removeAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    removeRoles: BelongsToManyRemoveMany<RoleInstance, RoleId>;
+    // hasRole...
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyRemoveMany<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Un-associate several instances.
+   * @param oldAssociated An array of instances or primary key of instances to un-associate.
+   * @param options The options passed to `through.destroy`.
+   */
+  (oldAssociateds?: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: BelongsToManyRemoveManyOptions & InstanceDestroyOptions): Promise<void>, ... }
+
+
+  /**
+   * The options for the hasAssociation mixin of the belongsToMany association.
+   * @see  BelongsToManyHasOne
+   */
+  declare export type BelongsToManyHasOneOptions = {...}
+
+
+  /**
+   * The hasAssociation mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    hasRole: BelongsToManyHasOne<RoleInstance, RoleId>;
+    // hasRoles...
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyHasOne<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Check if an instance is associated with this.
+   * @param target The instance or the primary key of the instance to check.
+   * @param options The options passed to `getAssociations`.
+   */
+  (target: TInstance | TInstancePrimaryKey, options?: BelongsToManyHasOneOptions & BelongsToManyGetManyOptions): Promise<boolean>, ... }
+
+
+  /**
+   * The options for the hasAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManyHasMany
+   */
+  declare export type BelongsToManyHasManyOptions = {...}
+
+
+  /**
+   * The removeAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles
+    // hasRole...
+    hasRoles: BelongsToManyHasMany<RoleInstance, RoleId>;
+    // countRoles...
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyHasMany<TInstance: Model<any>, TInstancePrimaryKey> = { /**
+   * Check if all instances are associated with this.
+   * @param targets An array of instances or primary key of instances to check.
+   * @param options The options passed to `getAssociations`.
+   */
+  (targets: $ReadOnlyArray<TInstance | TInstancePrimaryKey>, options?: BelongsToManyHasManyOptions & BelongsToManyGetManyOptions): Promise<boolean>, ... }
+
+
+  /**
+   * The options for the countAssociations mixin of the belongsToMany association.
+   * @see  BelongsToManyCount
+   */
+  declare export type BelongsToManyCountOptions = {
+   /**
+    * An optional where clause to limit the associated models.
+    */
+   where?: WhereOptions,
+   /**
+    * Apply a scope on the related model, or remove its default scope by passing false.
+    */
+   scope?: ?(string | boolean),
+   ...
+  }
+
+
+  /**
+   * The countAssociations mixin applied to models with belongsToMany.
+   * An example of usage is as follows:
+
+  ```js
+
+  User.belongsToMany(Role, { through: UserRole });
+
+  interface UserInstance extends Model<UserInstance, UserAttributes>, UserAttributes {
+    // getRoles...
+    // setRoles...
+    // addRoles...
+    // addRole...
+    // createRole...
+    // removeRole...
+    // removeRoles...
+    // hasRole...
+    // hasRoles...
+    countRoles: BelongsToManyCount;
+  }
+  ```
+   * @see  http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/
+   * @see  Model
+  */
+  declare export type BelongsToManyCount = { /**
+   * Count everything currently associated with this, using an optional where clause.
+   * @param options The options to use when counting the associations.
+   */
+  (options?: BelongsToManyCountOptions): Promise<number>, ... }
+
+
+  /**
+   * Foreign Key Options
+   * @see  AssociationOptions
+   */
+  declare export type AssociationForeignKeyOptions = ColumnOptions & { /**
+   * Attribute name for the relation
+   */
+  name?: string, ... }
+
+
+
+  /**
+   * Options provided when associating models
+   * @see  Association class
+   */
+  declare export type AssociationOptions = {
+   /**
+    * Set to true to run before-/afterDestroy hooks when an associated model is deleted because of a cascade.
+    * For example if `User.hasOne(Profile, {onDelete: 'cascade', hooks:true})`, the before-/afterDestroy hooks
+   for profile will be called when a user is deleted. Otherwise the profile will be deleted without invoking
+   any hooks.
+
+   Defaults to false
+   */
+   hooks?: boolean,
+   /**
+    * The alias of this model, in singular form. See also the `name` option passed to `sequelize.define`. If
+    * you create multiple associations between the same tables, you should provide an alias to be able to
+   distinguish between them. If you provide an alias when creating the assocition, you should provide the
+   same alias when eager loading and when getting assocated models. Defaults to the singularized name of
+   target
+   */
+   as?: string | {
+    singular: string,
+    plural: string,
+    ...
+   },
+   /**
+    * The name of the foreign key in the target table or an object representing the type definition for the
+    * foreign column (see `Sequelize.define` for syntax). When using an object, you can add a `name` property
+   to set the name of the column. Defaults to the name of source + primary key of source
+   */
+   foreignKey?: string | AssociationForeignKeyOptions,
+   /**
+    * What happens when delete occurs.
+    *
+   Cascade if this is a n:m, and set null if it is a 1:m
+
+   Defaults to 'SET_NULL' or 'CASCADE'
+   */
+   onDelete?: string,
+   /**
+    * What happens when update occurs
+    *
+   Defaults to 'CASCADE'
+   */
+   onUpdate?: string,
+   /**
+    * Should on update and on delete constraints be enabled on the foreign key.
+    */
+   constraints?: boolean,
+   foreignKeyConstraint?: boolean,
+   ...
+  }
+
+
+  /**
+   * Options for Association Scope
+   * @see  AssociationOptionsManyToMany
+   */
+  declare export type AssociationScope = { [scopeName: string]: any, ... }
+
+
+  /**
+   * Options provided for many-to-many relationships
+   * @see  AssociationOptionsHasMany
+   * @see  AssociationOptionsBelongsToMany
+   */
+  declare export type AssociationOptionsManyToMany = AssociationOptions & { /**
+   * A key/value set that will be used for association create and find defaults on the target.
+   * (sqlite not supported for N:M)
+   */
+  scope?: ?AssociationScope, ... }
+
+
+
+  /**
+   * Options provided when associating models with hasOne relationship
+   * @see  Association class hasOne method
+   */
+  declare export type AssociationOptionsHasOne = AssociationOptions & { /**
+   * A string or a data type to represent the identifier in the table
+   */
+  keyType?: DataTypeAbstract, ... }
+
+
+
+  /**
+   * Options provided when associating models with belongsTo relationship
+   * @see  Association class belongsTo method
+   */
+  declare export type AssociationOptionsBelongsTo = AssociationOptions & {
+   /**
+    * The name of the field to use as the key for the association in the target table. Defaults to the primary
+    * key of the target table
+    */
+   targetKey?: string,
+   /**
+    * A string or a data type to represent the identifier in the table
+    */
+   keyType?: DataTypeAbstract,
+   ...
+  }
+
+
+
+  /**
+   * Options provided when associating models with hasMany relationship
+   * @see  Association class hasMany method
+   */
+  declare export type AssociationOptionsHasMany = AssociationOptionsManyToMany & { /**
+   * A string or a data type to represent the identifier in the table
+   */
+  keyType?: DataTypeAbstract, ... }
+
+
+
+  /**
+   * Options provided when associating models with belongsToMany relationship
+   * @see  Association class belongsToMany method
+   */
+  declare export type AssociationOptionsBelongsToMany<Through: Model<any>> = AssociationOptionsManyToMany & {
+   /**
+    * The name of the table that is used to join source and target in n:m associations. Can also be a
+    * sequelize
+   model if you want to define the junction table yourself and add extra attributes to it.
+
+   In 3.4.1 version of Sequelize, hasMany's use of through gives an error, and on the other hand through
+   option for belongsToMany has been made required.
+    * @see  https://github.com/sequelize/sequelize/blob/v3.4.1/lib/associations/has-many.js
+    * @see  https://github.com/sequelize/sequelize/blob/v3.4.1/lib/associations/belongs-to-many.js
+   */
+   through: Class<Through> | string | ThroughOptions<Through>,
+   /**
+    * The name of the foreign key in the join table (representing the target model) or an object representing
+    * the type definition for the other column (see `Sequelize.define` for syntax). When using an object, you
+   can add a `name` property to set the name of the colum. Defaults to the name of target + primary key of
+   target
+   */
+   otherKey?: string | AssociationForeignKeyOptions,
+   /**
+    * Should the join model have timestamps
+    */
+   timestamps?: boolean,
+   ...
+  }
+
+
+
+  /**
+   * Used for a association table in n:m associations.
+   * @see  AssociationOptionsBelongsToMany
+   */
+  declare export type ThroughOptions<TInstance: Model<any>> = {
+   /**
+    * The model used to join both sides of the N:M association.
+    */
+   model: Class<TInstance>,
+   /**
+    * A key/value set that will be used for association create and find defaults on the through model.
+    * (Remember to add the attributes to the through model)
+    */
+   scope?: ?AssociationScope,
+   /**
+    * If true a unique key will be generated from the foreign keys used (might want to turn this off and create
+    * specific unique keys when using scopes)
+
+   Defaults to true
+   */
+   unique?: boolean,
+   ...
+  }
+
+  declare type AssociationType = 'HasMany' | 'BelongsTo' | 'HasOne' | 'BelongsToMany'
+
+  declare export type Attribute = {
+   /**
+    * A string or a data type
+    */
+   type: DataTypeAbstract,
+   allowNull?: boolean,
+   values?: Array<any>,
+   /**
+    * If true, the column will get a unique constraint. If a string is provided, the column will be part of a
+    * composite unique index. If multiple columns have the same string, they will be part of the same unique
+   index
+   */
+   unique?: boolean | string | {
+    name: string,
+    msg: string,
+    ...
+   },
+   /**
+    * Primary key flag
+    */
+   primaryKey?: boolean,
+   /**
+    * Is this field an auto increment field
+    */
+   autoIncrement?: boolean,
+   /**
+    * Comment for the database
+    */
+   comment?: string,
+   /**
+    * An object with reference configurations
+    */
+   references?: string | Model<any> | DefineAttributeColumnReferencesOptions,
+   Model: Model<any>,
+   _autoGenerated?: true,
+   fieldName: string,
+   field: string,
+   ...
+  }
+
+  declare export class Association<Source: Model<any>, Target: Model<any>> {
+    constructor(source: Class<Source>, target: Class<Target>, options?: AssociationOptions): this;
+    static BelongsTo: typeof BelongsTo;
+    static HasOne: typeof HasOne;
+    static BelongsToMany: typeof BelongsToMany;
+    static HasMany: typeof HasMany;
+    source: Class<Source>;
+    target: Class<Target>;
+    sequelize: Sequelize;
+    options: AssociationOptions;
+    scope: ?AssociationScope;
+    isSingleAssociation: boolean;
+    isMultiAssociation: boolean;
+    isSelfAssociation: boolean;
+    as: string | {
+     singular: string,
+     plural: string,
+     ...
+    };
+    +associationType: AssociationType;
+  }
+
+  declare type ArrayOrElement<T> = T | Array<T>;
+
+  declare class BelongsTo<Source: Model<any>, TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>> extends Association<Source, Target> {
+    +associationType: 'BelongsTo';
+    foreignKey: string;
+    foreignKeyField: string;
+    foreignKeyAttribute: Attribute;
+    identifier: string;
+    targetKey: string;
+    targetKeyField: string;
+    targetKeyAttribute: string;
+    targetIdentifier: string;
+    targetKeyIsPrimary: boolean;
+    identifierField: string;
+    get(instance: Source, options?: FindOptions<TargetAttributes>): Promise<Target>;
+    get<PrimaryKey>(instances: Array<Source>, options?: FindOptions<TargetAttributes>): Promise<{ [key: PrimaryKey]: Target, ... }>;
+    set<PrimaryKey>(sourceInstance: Source, targetInstance: PrimaryKey | Target, options?: InstanceSaveOptions<TargetAttributes>): Promise<void>;
+    create(sourceInstance: Source, values: TargetInitAttributes, options?: CreateOptions<TargetAttributes>): Promise<Target>;
+  }
+
+  declare class HasOne<Source: Model<any>, TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>> extends Association<Source, Target> {
+    +associationType: 'HasOne';
+    foreignKey: string;
+    foreignKeyField: string;
+    foreignKeyAttribute: Attribute;
+    identifier: string;
+    sourceKey: string;
+    sourceKeyField: string;
+    sourceKeyAttribute: string;
+    sourceKeyIsPrimary: boolean;
+    sourceIdentifier: string;
+    identifierField: string;
+    get(instance: Source, options?: FindOptions<TargetAttributes>): Promise<Target>;
+    get<PrimaryKey>(instances: Array<Source>, options?: FindOptions<TargetAttributes>): Promise<{ [key: PrimaryKey]: Target, ... }>;
+    set<PrimaryKey>(sourceInstance: Source, targetInstance: PrimaryKey | Target, options?: InstanceSaveOptions<TargetAttributes>): Promise<void>;
+    create(sourceInstance: Source, values: TargetInitAttributes, options?: CreateOptions<TargetAttributes>): Promise<Target>;
+  }
+
+  declare class HasMany<Source: Model<any>, TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>> extends Association<Source, Target> {
+    +associationType: 'HasMany';
+    foreignKey: string;
+    foreignKeyField: string;
+    foreignKeyAttribute: Attribute;
+    sourceKey: string;
+    sourceKeyField: string;
+    sourceKeyAttribute: string;
+    identifierField: string;
+    get(instance: Source, options?: FindOptions<TargetAttributes>): Promise<Array<Target>>;
+    get<PrimaryKey>(instances: Array<Source>, options?: FindOptions<TargetAttributes>): Promise<{ [key: PrimaryKey]: Target, ... }>;
+    count(instance: Source, options?: FindOptions<TargetAttributes>): Promise<number>;
+    has<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: FindOptions<TargetAttributes>): Promise<boolean>;
+    set<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: FindOptions<TargetAttributes> & UpdateRelatedOptions<TargetAttributes>): Promise<Source>;
+    add<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: UpdateRelatedOptions<TargetAttributes>): Promise<Source>;
+    remove<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: UpdateRelatedOptions<TargetAttributes>): Promise<this>;
+    create(sourceInstance: Source, values: TargetInitAttributes, options?: CreateOptions<TargetAttributes>): Promise<Target>;
+  }
+
+  declare class BelongsToMany<
+    SourceAttributes: Object,
+    SourceInitAttributes: Object,
+    Source: Model<SourceAttributes, SourceInitAttributes>,
+    TargetAttributes: Object,
+    TargetInitAttributes: Object,
+    Target: Model<TargetAttributes, TargetInitAttributes>,
+    ThroughAttributes: Object,
+    Through: Model<ThroughAttributes, any>
+  > extends Association<Source, Target> {
+    +associationType: 'BelongsToMany';
+    foreignKey: string;
+    foreignKeyField: string;
+    foreignKeyAttribute: Attribute;
+    otherKey: string;
+    otherKeyField: string;
+    otherKeyAttribute: string;
+    identifierField: string;
+    foreignIdentifierField?: string;
+    paired?: BelongsToMany<TargetAttributes, TargetInitAttributes, Target, SourceAttributes, SourceInitAttributes, Source, ThroughAttributes, Through>;
+    through: ThroughOptions<Through>;
+    throughModel: Class<Through>;
+    get(instance: Source, options?: FindOptions<TargetAttributes>): Promise<Array<Target>>;
+    count(instance: Source, options?: FindOptions<TargetAttributes>): Promise<number>;
+    has<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: FindOptions<TargetAttributes>): Promise<boolean>;
+    set<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: FindOptions<TargetAttributes> & UpdateRelatedOptions<TargetAttributes> & DestroyOptions): Promise<Array<any>>;
+    add<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: FindOptions<TargetAttributes> & UpdateRelatedOptions<TargetAttributes>): Promise<Array<any>>;
+    remove<PrimaryKey>(sourceInstance: Source, targetInstances: ArrayOrElement<PrimaryKey | Target>, options?: DestroyOptions): Promise<void>;
+    create(sourceInstance: Source, values: TargetInitAttributes, options?: CreateOptions<TargetAttributes>): Promise<Target>;
+  }
+
+  /**
+   * Abstract DataType interface. Use this if you want to create an interface that has a value any of the
+   * DataTypes that Sequelize supports.
+   */
+  declare export type DataTypeAbstract = {
+   /**
+    * Although this is not needed for the definitions itself, we want to make sure that DataTypeAbstract is not
+    * something than can be evaluated to an empty object.
+    */
+   dialectTypes: string,
+   toSql(): string,
+   ...
+  }
+
+  declare type DataTypeAbstractString<T> = {
+   /**
+    * A variable length string. Default length 255
+    */
+   (options?: { length: number, ... }): T,
+   (length: number): T,
+   /**
+    * Property BINARY for the type
+    */
+   BINARY: T,
+   ...
+  } & DataTypeAbstract
+
+
+  declare type DataTypeString = {...} & DataTypeAbstractString<DataTypeString>
+
+
+  declare type DataTypeChar = {...} & DataTypeAbstractString<DataTypeString>
+
+
+  declare type DataTypeText = DataTypeAbstract & {
+   /**
+    * Length of the text field.
+    *
+   Available lengths: `tiny`, `medium`, `long`
+   */
+   (options?: { length: string, ... }): DataTypeText,
+   (length: string): DataTypeText,
+   ...
+  }
+
+
+  declare type DataTypeAbstractNumber<T> = DataTypeAbstract & {
+   UNSIGNED: T,
+   ZEROFILL: T,
+   ...
+  }
+
+
+  declare type DataTypeNumber = DataTypeAbstractNumber<DataTypeNumber> & {...}
+
+
+  declare type DataTypeInteger = DataTypeAbstractNumber<DataTypeInteger> & {
+   /**
+    * Length of the number field.
+    */
+   (options?: { length: number, ... }): DataTypeInteger,
+   (length: number): DataTypeInteger,
+   ...
+  }
+
+
+  declare type DataTypeBigInt = DataTypeAbstractNumber<DataTypeBigInt> & {
+   /**
+    * Length of the number field.
+    */
+   (options?: { length: number, ... }): DataTypeBigInt,
+   (length: number): DataTypeBigInt,
+   ...
+  }
+
+
+  declare type DataTypeFloat = DataTypeAbstractNumber<DataTypeFloat> & {
+   /**
+    * Length of the number field and decimals of the float
+    */
+   (options?: {
+    length: number,
+    decimals?: number,
+    ...
+   }): DataTypeFloat,
+   (length: number, decimals?: number): DataTypeFloat,
+   ...
+  }
+
+
+  declare type DataTypeReal = DataTypeAbstractNumber<DataTypeReal> & {
+   /**
+    * Length of the number field and decimals of the real
+    */
+   (options?: {
+    length: number,
+    decimals?: number,
+    ...
+   }): DataTypeReal,
+   (length: number, decimals?: number): DataTypeReal,
+   ...
+  }
+
+
+  declare type DataTypeDouble = DataTypeAbstractNumber<DataTypeDouble> & {
+   /**
+    * Length of the number field and decimals of the real
+    */
+   (options?: {
+    length: number,
+    decimals?: number,
+    ...
+   }): DataTypeDouble,
+   (length: number, decimals?: number): DataTypeDouble,
+   ...
+  }
+
+
+  declare type DataTypeDecimal = DataTypeAbstractNumber<DataTypeDecimal> & {
+   /**
+    * Precision and scale for the decimal number
+    */
+   (options?: {
+    precision: number,
+    scale?: number,
+    ...
+   }): DataTypeDecimal,
+   (precision: number, scale?: number): DataTypeDecimal,
+   ...
+  }
+
+
+  declare type DataTypeBoolean = DataTypeAbstract & {...}
+
+
+  declare type DataTypeTime = DataTypeAbstract & {...}
+
+
+  declare type DataTypeDate = DataTypeAbstract & {
+   /**
+    * Length of decimal places of time
+    */
+   (options?: { length?: number, ... }): DataTypeDate,
+   (length?: number): DataTypeDate,
+   ...
+  }
+
+
+  declare type DataTypeDateOnly = DataTypeAbstract & {...}
+
+
+  declare type DataTypeHStore = DataTypeAbstract & {...}
+
+
+  declare type DataTypeJSONType = DataTypeAbstract & {...}
+
+
+  declare type DataTypeJSONB = DataTypeAbstract & {...}
+
+
+  declare type DataTypeNow = DataTypeAbstract & {...}
+
+
+  declare type DataTypeBlob = DataTypeAbstract & {
+   /**
+    * Length of the blob field.
+    *
+   Available lengths: `tiny`, `medium`, `long`
+   */
+   (options?: { length: string, ... }): DataTypeBlob,
+   (length: string): DataTypeBlob,
+   ...
+  }
+
+
+  declare type DataTypeRange = DataTypeAbstract & {
+   /**
+    * Range field for Postgre
+    *
+   Accepts subtype any of the ranges
+   */
+   (options?: { subtype: DataTypeAbstract, ... }): DataTypeRange,
+   (subtype: DataTypeAbstract): DataTypeRange,
+   ...
+  }
+
+
+  declare type DataTypeUUID = DataTypeAbstract & {...}
+
+
+  declare type DataTypeUUIDv1 = DataTypeAbstract & {...}
+
+
+  declare type DataTypeUUIDv4 = DataTypeAbstract & {...}
+
+  declare class DataTypeVirtualClass {
+    constructor(subtype: DataTypeAbstract, requireAttributes?: Array<string>): DataTypeVirtual;
+  }
+
+  declare type DataTypeVirtual = DataTypeAbstract & typeof DataTypeVirtualClass & { (subtype: DataTypeAbstract, requireAttributes?: Array<string>): DataTypeVirtual, ... }
+
+  declare type DataTypeEnum = DataTypeAbstract & {
+   /**
+    * Enum field
+    *
+   Accepts values
+   */
+   (options?: { values: string | string[], ... }): DataTypeEnum,
+   (values: string | string[]): DataTypeEnum,
+   (...args: string[]): DataTypeEnum,
+   ...
+  }
+
+
+  declare type DataTypeArray = DataTypeAbstract & {
+   /**
+    * Array field for Postgre
+    *
+   Accepts type any of the DataTypes
+   */
+   (options: { type: DataTypeAbstract, ... }): DataTypeArray,
+   (type: DataTypeAbstract): DataTypeArray,
+   ...
+  }
+
+
+  declare type DataTypeGeometry = DataTypeAbstract & { /**
+   * Geometry field for Postgres
+   */
+  (type: string, srid?: number): DataTypeGeometry, ... }
+
+
+
+  /**
+   * A convenience class holding commonly used data types. The datatypes are used when definining a new model
+   * using
+  `Sequelize.define`, like this:
+
+  ```js
+  sequelize.define('model', {
+  column: DataTypes.INTEGER
+  })
+  ```
+  When defining a model you can just as easily pass a string as type, but often using the types defined here
+  is
+  beneficial. For example, using `DataTypes.BLOB`, mean that that column will be returned as an instance of
+  `Buffer` when being fetched by sequelize.
+
+  Some data types have special properties that can be accessed in order to change the data type.
+  For example, to get an unsigned integer with zerofill you can do `DataTypes.INTEGER.UNSIGNED.ZEROFILL`.
+  The order you access the properties in do not matter, so `DataTypes.INTEGER.ZEROFILL.UNSIGNED` is fine as
+  well. The available properties are listed under each data type.
+
+  To provide a length for the data type, you can invoke it like a function: `INTEGER(2)`
+
+  Three of the values provided here (`NOW`, `UUIDV1` and `UUIDV4`) are special default values, that should not
+  be used to define types. Instead they are used as shorthands for defining default values. For example, to
+  get a uuid field with a default value generated following v1 of the UUID standard:
+
+  ```js
+  sequelize.define('model', {
+  uuid: {
+  type: DataTypes.UUID,
+  defaultValue: DataTypes.UUIDV1,
+  primaryKey: true
+  }
+  })
+  ```
+  */
+  declare export type DataTypes = {
+   ABSTRACT: DataTypeAbstract,
+   STRING: DataTypeString,
+   CHAR: DataTypeChar,
+   TEXT: DataTypeText,
+   NUMBER: DataTypeNumber,
+   INTEGER: DataTypeInteger,
+   BIGINT: DataTypeBigInt,
+   FLOAT: DataTypeFloat,
+   TIME: DataTypeTime,
+   DATE: DataTypeDate,
+   DATEONLY: DataTypeDateOnly,
+   BOOLEAN: DataTypeBoolean,
+   NOW: DataTypeNow,
+   BLOB: DataTypeBlob,
+   DECIMAL: DataTypeDecimal,
+   NUMERIC: DataTypeDecimal,
+   UUID: DataTypeUUID,
+   UUIDV1: DataTypeUUIDv1,
+   UUIDV4: DataTypeUUIDv4,
+   HSTORE: DataTypeHStore,
+   JSON: DataTypeJSONType,
+   JSONB: DataTypeJSONB,
+   VIRTUAL: DataTypeVirtual,
+   ARRAY: DataTypeArray,
+   NONE: DataTypeVirtual,
+   ENUM: DataTypeEnum,
+   RANGE: DataTypeRange,
+   REAL: DataTypeReal,
+   DOUBLE: DataTypeDouble,
+   GEOMETRY: DataTypeGeometry,
+   ...
+  }
+
+
+  /**
+   * Abstract Deferrable interface. Use this if you want to create an interface that has a value any of the
+   * Deferrables that Sequelize supports.
+   */
+  declare export type DeferrableAbstract = {
+   /**
+    * Although this is not needed for the definitions itself, we want to make sure that DeferrableAbstract is
+    * not something than can be evaluated to an empty object.
+    */
+   toString(): string,
+   toSql(): string,
+   ...
+  }
+
+  declare export type DeferrableInitiallyDeferred = { /**
+   * A property that will defer constraints checks to the end of transactions.
+   */
+  (): DeferrableInitiallyDeferred, ... } & DeferrableAbstract
+
+
+  declare export type DeferrableInitiallyImmediate = { /**
+   * A property that will trigger the constraint checks immediately
+   */
+  (): DeferrableInitiallyImmediate, ... } & DeferrableAbstract
+
+
+  declare export type DeferrableNot = { /**
+   * A property that will set the constraints to not deferred. This is the default in PostgreSQL and it make
+   * it impossible to dynamically defer the constraints within a transaction.
+   */
+  (): DeferrableNot, ... } & DeferrableAbstract
+
+
+  declare export type DeferrableSetDeferred = { /**
+   * A property that will trigger an additional query at the beginning of a
+   * transaction which sets the constraints to deferred.
+   * @param constraints An array of constraint names. Will defer all constraints by default.
+   */
+  (constraints: string[]): DeferrableSetDeferred, ... } & DeferrableAbstract
+
+
+  declare export type DeferrableSetImmediate = { /**
+   * A property that will trigger an additional query at the beginning of a
+   * transaction which sets the constraints to immediately.
+   * @param constraints An array of constraint names. Will defer all constraints by default.
+   */
+  (constraints: string[]): DeferrableSetImmediate, ... } & DeferrableAbstract
+
+
+
+  /**
+   * A collection of properties related to deferrable constraints. It can be used to
+   * make foreign key constraints deferrable and to set the constaints within a
+  transaction. This is only supported in PostgreSQL.
+
+  The foreign keys can be configured like this. It will create a foreign key
+  that will check the constraints immediately when the data was inserted.
+
+  ```js
+  sequelize.define('Model', {
+     foreign_id: {
+     type: Sequelize.INTEGER,
+     references: {
+       model: OtherModel,
+       key: 'id',
+       deferrable: Sequelize.Deferrable.INITIALLY_IMMEDIATE
+     }
+     }
+  });
+  ```
+
+  The constraints can be configured in a transaction like this. It will
+  trigger a query once the transaction has been started and set the constraints
+  to be checked at the very end of the transaction.
+
+  ```js
+  sequelize.transaction({
+  deferrable: Sequelize.Deferrable.SET_DEFERRED
+  });
+  ```
+  */
+  declare export type Deferrable = {
+   INITIALLY_DEFERRED: DeferrableInitiallyDeferred,
+   INITIALLY_IMMEDIATE: DeferrableInitiallyImmediate,
+   NOT: DeferrableNot,
+   SET_DEFERRED: DeferrableSetDeferred,
+   SET_IMMEDIATE: DeferrableSetImmediate,
+   ...
+  }
+
+
+  /**
+   * The Base Error all Sequelize Errors inherit from.
+   */
+  declare export class BaseError extends Error {
+
+  }
+
+  declare export class ValidationError extends BaseError {
+    /**
+     * Validation Error. Thrown when the sequelize validation has failed. The error contains an `errors`
+     * property, which is an array with 1 or more ValidationErrorItems, one for each validation that failed.
+     * @param message Error message
+     * @param errors Array of ValidationErrorItem objects describing the validation errors
+     */
+    constructor(
+      message: string,
+      errors?: ValidationErrorItem[]): ValidationError,
+
+    /**
+     * Gets all validation error items for the path / field specified.
+     * @param path The path to be checked for error items
+     */
+    get(path: string): ValidationErrorItem[],
+
+    /**
+     * Array of ValidationErrorItem objects describing the validation errors
+     */
+    errors: ValidationErrorItem[]
+  }
+
+
+  declare export class ValidationErrorItem extends BaseError {
+    /**
+     * Validation Error Item
+     * Instances of this class are included in the `ValidationError.errors` property.
+     * @param message An error message
+     * @param type The type of the validation error
+     * @param path The field that triggered the validation error
+     * @param value The value that generated the error
+     */
+    constructor(
+      message: string,
+      type: string,
+      path: string,
+      value: string): ValidationErrorItem,
+
+    /**
+     * An error message
+     */
+    message: string,
+
+    /**
+     * The type of the validation error
+     */
+    type: string,
+
+    /**
+     * The field that triggered the validation error
+     */
+    path: string,
+
+    /**
+     * The value that generated the error
+     */
+    value: string
+  }
+
+
+  declare export class DatabaseError extends BaseError {
+    /**
+     * A base class for all database related errors.
+     */
+    constructor(parent: Error): DatabaseError
+  }
+
+
+  declare export class TimeoutError extends DatabaseError {
+    /**
+     * Thrown when a database query times out because of a deadlock
+     */
+    constructor(parent: Error): TimeoutError
+  }
+
+
+  declare export class UniqueConstraintError extends ValidationError {
+    /**
+     * Thrown when a unique constraint is violated in the database
+     */
+    constructor(
+      options: {
+       parent?: Error,
+       message?: string,
+       errors?: Object,
+       ...
+      }): UniqueConstraintError
+  }
+
+
+  declare export class ForeignKeyConstraintError extends DatabaseError {
+    /**
+     * Thrown when a foreign key constraint is violated in the database
+     */
+    construtor(
+      options: {
+       parent?: Error,
+       message?: string,
+       index?: string,
+       fields?: string[],
+       table?: string,
+       ...
+      }): ForeignKeyConstraintError
+  }
+
+
+  declare export class ExclusionConstraintError extends DatabaseError {
+    /**
+     * Thrown when an exclusion constraint is violated in the database
+     */
+    construtor(
+      options: {
+       parent?: Error,
+       message?: string,
+       constraint?: string,
+       fields?: string[],
+       table?: string,
+       ...
+      }): ExclusionConstraintError
+  }
+
+
+  declare export class ConnectionError extends BaseError {
+    /**
+     * A base class for all connection related errors.
+     */
+    construtor(parent: Error): ConnectionError
+  }
+
+
+  declare export class ConnectionRefusedError extends ConnectionError {
+    /**
+     * Thrown when a connection to a database is refused
+     */
+    construtor(parent: Error): ConnectionRefusedError
+  }
+
+
+  declare export class AccessDeniedError extends ConnectionError{
+    /**
+     * Thrown when a connection to a database is refused due to insufficient privileges
+     */
+    construtor(parent: Error): AccessDeniedError
+  }
+
+
+  declare export class HostNotFoundError extends ConnectionError {
+    /**
+     * Thrown when a connection to a database has a hostname that was not found
+     */
+    construtor(parent: Error): HostNotFoundError
+  }
+
+
+  declare export class HostNotReachableError extends ConnectionError {
+    /**
+     * Thrown when a connection to a database has a hostname that was not reachable
+     */
+    construtor(parent: Error): HostNotReachableError
+  }
+
+
+  declare export class InvalidConnectionError extends ConnectionError {
+    /**
+     * Thrown when a connection to a database has invalid values for any of the connection parameters
+     */
+    construtor(parent: Error): InvalidConnectionError
+  }
+
+
+  declare export class ConnectionTimedOutError extends ConnectionError {
+    /**
+     * Thrown when a connection to a database times out
+     */
+    construtor(parent: Error): ConnectionTimedOutError
+  }
+
+
+  declare export class EmptyResultError extends BaseError {
+    /**
+     * Thrown when a record was not found, Usually used with rejectOnEmpty mode (see message for details)
+     */
+    construtor(parent: Error): EmptyResultError
+  }
+
+  /**
+   * Options for Sequelize.define. We mostly duplicate the Hooks here, since there is no way to combine the two
+   * interfaces.
+
+  beforeValidate, afterValidate, beforeBulkCreate, beforeBulkDestroy, beforeBulkUpdate, beforeCreate,
+  beforeDestroy, beforeUpdate, afterCreate, afterDestroy, afterUpdate, afterBulkCreate, afterBulkDestroy and
+  afterBulkUpdate.
+  */
+  declare export type HooksDefineOptions<TInstance: Model<any>> = {
+   beforeValidate?: AsyncFn2<TInstance, Object>,
+   validationFailed?: AsyncFn3<TInstance, Object, ValidationError>,
+   afterValidate?: AsyncFn2<TInstance, Object>,
+   beforeCreate?: AsyncFn2<TInstance, Object>,
+   afterCreate?: AsyncFn2<TInstance, Object>,
+   beforeDestroy?: AsyncFn2<TInstance, Object>,
+   beforeDelete?: AsyncFn2<TInstance, Object>,
+   afterDestroy?: AsyncFn2<TInstance, Object>,
+   afterDelete?: AsyncFn2<TInstance, Object>,
+   beforeUpdate?: AsyncFn2<TInstance, Object>,
+   afterUpdate?: AsyncFn2<TInstance, Object>,
+   beforeBulkCreate?: AsyncFn2<TInstance[], Object>,
+   afterBulkCreate?: AsyncFn2<TInstance[], Object>,
+   beforeBulkDestroy?: AsyncFn1<Object>,
+   beforeBulkDelete?: AsyncFn1<Object>,
+   afterBulkDestroy?: AsyncFn1<Object>,
+   afterBulkDelete?: AsyncFn1<Object>,
+   beforeBulkUpdate?: AsyncFn1<Object>,
+   afterBulkUpdate?: AsyncFn1<Object>,
+   beforeFind?: AsyncFn1<Object>,
+   beforeFindAfterExpandIncludeAll?: AsyncFn1<Object>,
+   beforeFindAfterOptions?: AsyncFn1<Object>,
+   afterFind?: AsyncFn2<TInstance | TInstance[], Object>,
+   ...
+  }
+
+
+  /**
+   * Options used for Instance.increment method
+   */
+  declare export type InstanceIncrementDecrementOptions = {
+   /**
+    * The number to increment by
+    * Defaults to 1
+    */
+   by?: number,
+   /**
+    * If true, the updatedAt timestamp will not be updated.
+    */
+   silent?: boolean,
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: boolean | Function,
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   /**
+    * An optional parameter to specify the schema search_path (Postgres only)
+    */
+   searchPath?: string,
+   ...
+  }
+
+
+  /**
+   * Options used for Instance.restore method
+   */
+  declare export type InstanceRestoreOptions = {
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: boolean | Function,
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   ...
+  }
+
+
+  /**
+   * Options used for Instance.destroy method
+   */
+  declare export type InstanceDestroyOptions = {
+   /**
+    * If set to true, paranoid models will actually be deleted
+    */
+   force?: boolean,
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: boolean | Function,
+   /**
+    * Transaction to run the query in
+    */
+   transaction?: ?Transaction,
+   ...
+  }
+
+
+  /**
+   * Options used for Instance.update method
+   */
+  declare export type InstanceUpdateOptions<TAttributes> = { /**
+   * A hash of attributes to describe your search. See above for examples.
+   */
+  where?: WhereOptions, ... } & InstanceSaveOptions<TAttributes> & InstanceSetOptions
+
+
+
+  /**
+   * Options used for Instance.set method
+   */
+  declare export type InstanceSetOptions = {
+   /**
+    * If set to true, field and virtual setters will be ignored
+    */
+   raw?: boolean,
+   /**
+    * Clear all previously set data values
+    */
+   reset?: boolean,
+   ...
+  }
+
+
+  /**
+   * Options used for Instance.save method
+   */
+  declare export type InstanceSaveOptions<TAttributes> = { /**
+   * If true, the updatedAt timestamp will not be updated.
+   *
+  Defaults to false
+  */
+  silent?: boolean, ... } & FieldsOptions<TAttributes> & LoggingOptions & ReturningOptions & SearchPathOptions
+
+  declare export type LoggingOptions = {
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: boolean | Function,
+   /**
+    * Print query execution time in milliseconds when logging SQL.
+    */
+   benchmark?: boolean,
+   ...
+  }
+
+  declare export type SearchPathOptions = {
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   /**
+    * An optional parameter to specify the schema search_path (Postgres only)
+    */
+   searchPath?: string,
+   ...
+  }
+
+  declare export type ReturningOptions = { /**
+   * Append RETURNING  to get back auto generated values (Postgres only)
+   */
+  returning?: boolean, ... }
+
+  declare export type FieldsOptions<TAttributes> = {
+   /**
+    * Run validations before the row is inserted
+    */
+   validate?: boolean,
+   /**
+    * The fields to insert / update. Defaults to all fields
+    */
+   fields?: $Keys<TAttributes>[],
+   ...
+  }
+
+
+  /**
+   * Options to pass to Model on drop
+   */
+  declare export type DropOptions = { /**
+   * Also drop all objects depending on this table, such as views. Only works in postgres
+   */
+  cascade?: boolean, ... } & LoggingOptions
+
+
+
+  /**
+   * Schema Options provided for applying a schema to a model
+   */
+  declare export type SchemaOptions = { /**
+   * The character(s) that separates the schema name from the table name
+   */
+  schemaDelimeter?: string, ... } & LoggingOptions
+
+
+
+  /**
+   * GetTableName Options
+   */
+  declare export type GetTableNameOptions = {...} & LoggingOptions
+
+
+
+  /**
+   * AddScope Options for Model.addScope
+   */
+  declare export type AddScopeOptions = { /**
+   * If a scope of the same name already exists, should it be overwritten?
+   */
+  override: boolean, ... }
+
+
+  /**
+   * Scope Options for Model.scope
+   */
+  declare export type ScopeOptions = { /**
+   * The scope(s) to apply. Scopes can either be passed as consecutive arguments, or as an array of arguments.
+   * To apply simple scopes and scope functions with no arguments, pass them as strings. For scope function,
+  pass an object, with a `method` property. The value can either be a string, if the method does not take
+  any arguments, or an array, where the first element is the name of the method, and consecutive elements
+  are arguments to that method. Pass null to remove all scopes, including the default.
+  */
+  method: string | any[], ... }
+
+  /**
+   * The type accepted by every `where` option
+   *
+   * The `Array<string | number>` is to support string with replacements, like `['id > ?', 25]`
+   */
+  declare export type WhereOptions = WhereAttributeHash | AndOperator | OrOperator | where | fn | $ReadOnlyArray<string | number | AndOperator | OrOperator>;
+
+  /**
+   * Example: `$any: [2,3]` becomes `ANY ARRAY[2, 3]::INTEGER`
+   *
+   * _PG only_
+   */
+  declare export type AnyOperator = { $any: $ReadOnlyArray<string | number>, ... }
+
+  /** Undocumented? */
+  declare export type AllOperator = { $all: $ReadOnlyArray<string | number>, ... }
+
+  /**
+   * Operators that can be used in WhereOptions
+   *
+   * See http://docs.sequelizejs.com/en/v3/docs/querying/#operators
+   */
+  declare export type WhereOperators = {
+   /**
+    * Example: `$any: [2,3]` becomes `ANY ARRAY[2, 3]::INTEGER`
+    *
+    * _PG only_
+    */
+   $any?: $ReadOnlyArray<string | number>,
+   /** Example: `$gte: 6,` becomes `>= 6` */
+   $gte?: number | string | Date,
+   /** Example: `$lt: 10,` becomes `< 10` */
+   $lt?: number | string | Date,
+   /** Example: `$lte: 10,` becomes `<= 10` */
+   $lte?: number | string | Date,
+   /** Example: `$ne: 20,` becomes `!= 20` */
+   $ne?: string | number | WhereOperators,
+   /** Example: `$not: true,` becomes `IS NOT TRUE` */
+   $not?: boolean | string | number | WhereOperators,
+   /** Example: `$between: [6, 10],` becomes `BETWEEN 6 AND 10` */
+   $between?: [number, number],
+   /** Example: `$in: [1, 2],` becomes `IN [1, 2]` */
+   $in?: $ReadOnlyArray<string | number> | literal,
+   /** Example: `$notIn: [1, 2],` becomes `NOT IN [1, 2]` */
+   $notIn?: $ReadOnlyArray<string | number> | literal,
+   /**
+    * Examples:
+    *  - `$like: '%hat',` becomes `LIKE '%hat'`
+    *  - `$like: { $any: ['cat', 'hat']}` becomes `LIKE ANY ARRAY['cat', 'hat']`
+    */
+   $like?: string | AnyOperator | AllOperator,
+   /**
+    * Examples:
+    *  - `$notLike: '%hat'` becomes `NOT LIKE '%hat'`
+    *  - `$notLike: { $any: ['cat', 'hat']}` becomes `NOT LIKE ANY ARRAY['cat', 'hat']`
+    */
+   $notLike?: string | AnyOperator | AllOperator,
+   /**
+    * case insensitive PG only
+    *
+    * Examples:
+    *  - `$iLike: '%hat'` becomes `ILIKE '%hat'`
+    *  - `$iLike: { $any: ['cat', 'hat']}` becomes `ILIKE ANY ARRAY['cat', 'hat']`
+    */
+   $ilike?: string | AnyOperator | AllOperator,
+   /**
+    * case insensitive PG only
+    *
+    * Examples:
+    *  - `$iLike: '%hat'` becomes `ILIKE '%hat'`
+    *  - `$iLike: { $any: ['cat', 'hat']}` becomes `ILIKE ANY ARRAY['cat', 'hat']`
+    */
+   $iLike?: string | AnyOperator | AllOperator,
+   /**
+    * PG array overlap operator
+    *
+    * Example: `$overlap: [1, 2]` becomes `&& [1, 2]`
+    */
+   $overlap?: [number, number],
+   /**
+    * PG array contains operator
+    *
+    * Example: `$contains: [1, 2]` becomes `@> [1, 2]`
+    */
+   $contains?: any[],
+   /**
+    * PG array contained by operator
+    *
+    * Example: `$contained: [1, 2]` becomes `<@ [1, 2]`
+    */
+   $contained?: any[],
+   /** Example: `$gt: 6,` becomes `> 6` */
+   $gt?: number | string | Date,
+   /**
+    * PG only
+    *
+    * Examples:
+    *  - `$notILike: '%hat'` becomes `NOT ILIKE '%hat'`
+    *  - `$notLike: ['cat', 'hat']` becomes `LIKE ANY ARRAY['cat', 'hat']`
+    */
+   $notILike?: string | AnyOperator | AllOperator,
+   /** Example: `$notBetween: [11, 15],` becomes `NOT BETWEEN 11 AND 15` */
+   $notBetween?: [number, number],
+   ...
+  } | { [op: Symbol]: any, ... }
+
+  /** Example: `$or: [{a: 5}, {a: 6}]` becomes `(a = 5 OR a = 6)` */
+  declare export type OrOperator = { [$or: Symbol | '$or']: WhereOperators | WhereAttributeHash | $ReadOnlyArray<Array<string> | Array<number> | WhereOperators | WhereAttributeHash | where | AndOperator>, ... }
+
+  /** Example: `$and: {a: 5}` becomes `AND (a = 5)` */
+  declare export type AndOperator = { [$and: Symbol | '$and']: WhereOperators | WhereAttributeHash | $ReadOnlyArray<Array<string> | Array<number> | WhereOperators | WhereAttributeHash | where | OrOperator>, ... }
+
+  /**
+   * Where Geometry Options
+   */
+  declare export type WhereGeometryOptions = {
+   type: string,
+   coordinates: $ReadOnlyArray<Array<number> | number>,
+   ...
+  }
+
+  /**
+   * Used for the right hand side of WhereAttributeHash.
+   * WhereAttributeHash is in there for JSON columns.
+   */
+  declare export type WhereValue =
+    string // literal value
+    | number // literal value
+    | boolean // literal value
+    | null
+    | WhereOperators
+    | WhereAttributeHash // for JSON columns
+    | col // reference another column
+    | OrOperator
+    | AndOperator
+    | WhereGeometryOptions
+    | $ReadOnlyArray<string | number | WhereAttributeHash>; // implicit $or
+
+  /**
+   * A hash of attributes to describe your search.
+   */
+  declare export type WhereAttributeHash = { /**
+   * Possible key values:
+   * - A simple attribute name
+   * - A nested key for JSON columns
+   *
+   *       {
+ *         "meta.audio.length": {
+ *           $gt: 20
+ *         }
+ *       }
+   */
+  [field: string]: WhereValue, ... }
+
+  /**
+   * Through options for Include Options
+   */
+  declare export type IncludeThroughOptions = {
+   /**
+    * Filter on the join model for belongsToMany relations
+    */
+   where?: WhereOptions,
+   /**
+    * A list of attributes to select from the join model for belongsToMany relations
+    */
+   attributes?: string[],
+   ...
+  }
+
+  /**
+   * Complex include options
+   */
+  declare export type IncludeOptions<TAttributes, TInstance: Model<TAttributes>> = {
+   /**
+    * The model you want to eagerly load
+    */
+   model?: Class<TInstance>,
+   /**
+    * The alias of the relation, in case the model you want to eagerly load is aliassed. For `hasOne` /
+    * `belongsTo`, this should be the singular name, and for `hasMany`, it should be the plural
+    */
+   as?: string,
+   /**
+    * The association you want to eagerly load. (This can be used instead of providing a model/as pair)
+    */
+   association?: Association<any, TInstance>,
+   /**
+    * Where clauses to apply to the child models. Note that this converts the eager load to an inner join,
+    * unless you explicitly set `required: false`
+    */
+   where?: WhereOptions,
+   /**
+    * A list of attributes to select from the child model
+    */
+   attributes?: FindOptionsAttributesArray<TAttributes> | {
+    include?: FindOptionsAttributesArray<TAttributes>,
+    exclude?: Array<$Keys<TAttributes>>,
+    ...
+   },
+   /**
+    * If true, converts to an inner join, which means that the parent model will only be loaded if it has any
+    * matching children. True if `include.where` is set, false otherwise.
+    */
+   required?: boolean,
+   /**
+    * Through Options
+    */
+   through?: IncludeThroughOptions,
+   /**
+    * Load further nested related models
+    */
+   include?: $ReadOnlyArray<Class<Model<any>> | IncludeOptions<any, any>>,
+   /**
+    * If true, only non-deleted records will be returned. If false, both deleted and non-deleted records will
+    * be returned. Only applies if `options.paranoid` is true for the model.
+    */
+   paranoid?: boolean,
+   all?: boolean | string,
+   ...
+  }
+
+
+  /**
+   * Shortcut for types used in FindOptions.attributes
+   */
+  declare export type FindOptionsAttributesArray<TAttributes> = Array<
+    $Keys<TAttributes> |
+    literal |
+    [fn, string] |
+    [cast, string] |
+    [literal, string] |
+    [$Keys<TAttributes>, string] |
+    fn |
+    cast
+  >;
+
+
+  /**
+   * Options that are passed to any model creating a SELECT query
+   *
+  A hash of options to describe the scope of the search
+  */
+  declare export type FindOptions<TAttributes>= {
+   /**
+    * A hash of attributes to describe your search. See above for examples.
+    */
+   where?: WhereOptions,
+   /**
+    * A list of the attributes that you want to select. To rename an attribute, you can pass an array, with
+    * two elements - the first is the name of the attribute in the DB (or some kind of expression such as
+   `Sequelize.literal`, `Sequelize.fn` and so on), and the second is the name you want the attribute to
+   have in the returned instance
+   */
+   attributes?: FindOptionsAttributesArray<TAttributes> | {
+    include?: FindOptionsAttributesArray<TAttributes>,
+    exclude?: Array<$Keys<TAttributes>>,
+    ...
+   },
+   /**
+    * If true, only non-deleted records will be returned. If false, both deleted and non-deleted records will
+    * be returned. Only applies if `options.paranoid` is true for the model.
+    */
+   paranoid?: boolean,
+   /**
+    * A list of associations to eagerly load using a left join. Supported is either
+    * `{ include: [ Model1, Model2, ...]}` or `{ include: [{ model: Model1, as: 'Alias' }]}`.
+   If your association are set up with an `as` (eg. `X.hasMany(Y, { as: 'Z }`, you need to specify Z in
+   the as attribute when eager loading Y).
+   */
+   include?: $ReadOnlyArray<Class<Model<any>> | IncludeOptions<any, any>>,
+   /**
+    * Specifies an ordering. If a string is provided, it will be escaped. Using an array, you can provide
+    * several columns / functions to order by. Each element can be further wrapped in a two-element array. The
+   first element is the column / function to order by, the second is the direction. For example:
+   `order: [['name', 'DESC']]`. In this way the column will be escaped, but the direction will not.
+   */
+   order?:
+     string |
+     col |
+     literal |
+     $ReadOnlyArray<
+       string |
+       col |
+       literal |
+       Class<Model<any>> |
+       {
+        model: Class<Model<any>>,
+        as?: string,
+        ...
+       } |
+       $ReadOnlyArray<
+         string |
+         number |
+         Class<Model<any>> |
+         {
+          model: Class<Model<any>>,
+          as?: string,
+          ...
+         }
+       >
+     >,
+   /**
+    * Limit the results
+    */
+   limit?: number,
+   /**
+    * Skip the results;
+    */
+   offset?: number,
+   /**
+    * Lock the selected rows. Possible options are transaction.LOCK.UPDATE and transaction.LOCK.SHARE.
+    * Postgres also supports transaction.LOCK.KEY_SHARE, transaction.LOCK.NO_KEY_UPDATE and specific model
+   locks with joins. See [transaction.LOCK for an example](transaction#lock)
+   */
+   lock?: TransactionLockLevel | {
+    level: TransactionLockLevel,
+    of: Class<Model<any>>,
+    ...
+   },
+   /**
+    * Return raw result. See sequelize.query for more information.
+    */
+   raw?: boolean,
+   /**
+    * having ?!?
+    */
+   having?: WhereOptions,
+   /**
+    * Group by. It is not mentioned in sequelize's JSDoc, but mentioned in docs.
+    * https://github.com/sequelize/sequelize/blob/master/docs/docs/models-usage.md#user-content-manipulating-the-dataset-with-limit-offset-order-and-group
+    */
+   group?: string | string[] | Object,
+   /**
+    * Apply DISTINCT(col) for FindAndCount(all)
+    */
+   distinct?: boolean,
+   /**
+    * Prevents a subquery on the main table when using include
+    */
+   subQuery?: boolean,
+   /**
+    * Throw EmptyResultError if a record is not found
+    */
+   rejectOnEmpty?: boolean,
+   ...
+  } & LoggingOptions & SearchPathOptions
+
+
+  declare export type AnyFindOptions = FindOptions<any>;
+
+
+  /**
+   * Options for Model.count method
+   */
+  declare export type CountOptions = {
+   /**
+    * A hash of search attributes.
+    */
+   where?: WhereOptions,
+   /**
+    * Include options. See `find` for details
+    */
+   include?: $ReadOnlyArray<Class<Model<any>>| IncludeOptions<any, any>>,
+   /**
+    * Apply COUNT(DISTINCT(col))
+    */
+   distinct?: boolean,
+   /**
+    * Used in conjustion with `group`
+    */
+   attributes?: $ReadOnlyArray<string | [string, string]>,
+   /**
+    * For creating complex counts. Will return multiple rows as needed.
+    *
+   TODO: Check?
+   */
+   group?: Object | Array<string>,
+   ...
+  } & LoggingOptions & SearchPathOptions
+
+
+
+  /**
+   * Options for Model.build method
+   */
+  declare export type BuildOptions = {
+   /**
+    * If set to true, values will ignore field and virtual setters.
+    */
+   raw?: boolean,
+   /**
+    * Is this record new
+    */
+   isNewRecord?: boolean,
+   /**
+    * an array of include options - Used to build prefetched/included model instances. See `set`
+    *
+   TODO: See set
+   */
+   include?: $ReadOnlyArray<Class<Model<any>> | IncludeOptions<any, any>>,
+   ...
+  } & ReturningOptions
+
+
+
+  /**
+   * Options for Model.create method
+   */
+  declare export type CreateOptions<TAttributes> = { /**
+   * On Duplicate
+   */
+  onDuplicate?: string, ... } & BuildOptions & InstanceSaveOptions<TAttributes>
+
+
+
+  /**
+   * Options for Model.findOrInitialize method
+   */
+  declare export type FindOrInitializeOptions<TAttributes>= { /**
+   * Default values to use if building a new instance
+   */
+  defaults?: $Shape<TAttributes>, ... } & FindOptions<TAttributes>
+
+
+
+  /**
+   * Options for Model.findOrInitialize method
+   */
+  declare export type FindCreateFindOptions<TAttributes>= { /**
+   * Default values to use if building a new instance
+   */
+  defaults?: $Shape<TAttributes>, ... } & FindOptions<TAttributes>
+
+
+
+  /**
+   * Options for Model.upsert method
+   *
+   */
+  declare export type UpsertOptions<TAttributes> = {...} & FieldsOptions<TAttributes> & LoggingOptions & SearchPathOptions
+
+
+
+  /**
+   * Options for Model.bulkCreate method
+   */
+  declare export type BulkCreateOptions<TAttributes> = {
+   /**
+    * Run before / after bulk create hooks?
+    */
+   hooks?: boolean,
+   /**
+    * Run before / after create hooks for each individual Instance? BulkCreate hooks will still be run if
+    * options.hooks is true.
+    */
+   individualHooks?: boolean,
+   /**
+    * Ignore duplicate values for primary keys? (not supported by postgres)
+    *
+   Defaults to false
+   */
+   ignoreDuplicates?: boolean,
+   /**
+    * Fields to update if row key already exists (on duplicate key update)? (only supported by mysql &
+    * mariadb). By default, all fields are updated.
+    */
+   updateOnDuplicate?: string[],
+   ...
+  } & FieldsOptions<TAttributes> & LoggingOptions & SearchPathOptions & ReturningOptions
+
+
+
+  /**
+   * The options passed to Model.destroy in addition to truncate
+   */
+  declare export type TruncateOptions = {
+   /**
+    * Only used in conjuction with TRUNCATE. Truncates  all tables that have foreign-key references to the
+    * named table, or to any tables added to the group due to CASCADE.
+
+   Defaults to false;
+   */
+   cascade?: boolean,
+   /**
+    * Delete instead of setting deletedAt to current timestamp (only applicable if paranoid is enabled)
+    *
+   Defaults to false;
+   */
+   force?: boolean,
+   ...
+  } & LoggingOptions & SearchPathOptions
+
+
+
+  /**
+   * Options used for Model.destroy
+   */
+  declare export type DestroyOptions = {
+   /**
+    * Filter the destroy
+    */
+   where?: WhereOptions,
+   /**
+    * Run before / after bulk destroy hooks?
+    */
+   hooks?: boolean,
+   /**
+    * If set to true, destroy will SELECT all records matching the where parameter and will execute before /
+    * after destroy hooks on each row
+    */
+   individualHooks?: boolean,
+   /**
+    * How many rows to delete
+    */
+   limit?: number,
+   /**
+    * Delete instead of setting deletedAt to current timestamp (only applicable if `paranoid` is enabled)
+    */
+   force?: boolean,
+   /**
+    * If set to true, dialects that support it will use TRUNCATE instead of DELETE FROM. If a table is
+    * truncated the where and limit options are ignored
+    */
+   truncate?: boolean,
+   ...
+  } & TruncateOptions
+
+  declare type AsyncFn1<A> = (a: A, callback: (error?: Error) => any) => ?Promise<void>
+  declare type AsyncFn2<A, B> = ((a: A, b: B, callback: (error?: Error) => any) => ?Promise<void>)
+  declare type AsyncFn3<A, B, C> = ((a: A, b: B, c: C, callback: (error?: Error) => any) => ?Promise<void>)
+
+  /**
+   * Options for Model.restore
+   */
+  declare export type RestoreOptions = {
+   /**
+    * Filter the restore
+    */
+   where?: WhereOptions,
+   /**
+    * Run before / after bulk restore hooks?
+    */
+   hooks?: boolean,
+   /**
+    * If set to true, restore will find all records within the where parameter and will execute before / after
+    * bulkRestore hooks on each row
+    */
+   individualHooks?: boolean,
+   /**
+    * How many rows to undelete
+    */
+   limit?: number,
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   ...
+  } & LoggingOptions
+
+  /**
+   * Options used for HasMany.update, BelongsToMany.update
+   */
+  declare export type UpdateRelatedOptions<TAttributes> = {
+   /**
+    * Options to describe the scope of the search.
+    */
+   where?: WhereOptions,
+   /**
+    * Run before / after bulk update hooks?
+    *
+    Defaults to true
+    */
+   hooks?: boolean,
+   /**
+    * Whether or not to update the side effects of any virtual setters.
+    *
+    Defaults to true
+    */
+   sideEffects?: boolean,
+   /**
+    * Run before / after update hooks?. If true, this will execute a SELECT followed by individual UPDATEs.
+    * A select is needed, because the row data needs to be passed to the hooks
+
+    Defaults to false
+    */
+   individualHooks?: boolean,
+   /**
+    * How many rows to update (only for mysql and mariadb)
+    */
+   limit?: number,
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   /**
+    * If true, the updatedAt timestamp will not be updated.
+    */
+   silent?: boolean,
+   ...
+  } & FieldsOptions<TAttributes> & LoggingOptions & ReturningOptions
+
+
+  /**
+   * Options used for Model.update
+   */
+  declare export type UpdateOptions<TAttributes> = {
+   /**
+    * Options to describe the scope of the search.
+    */
+   where: WhereOptions,
+   /**
+    * Run before / after bulk update hooks?
+    *
+   Defaults to true
+   */
+   hooks?: boolean,
+   /**
+    * Whether or not to update the side effects of any virtual setters.
+    *
+   Defaults to true
+   */
+   sideEffects?: boolean,
+   /**
+    * Run before / after update hooks?. If true, this will execute a SELECT followed by individual UPDATEs.
+    * A select is needed, because the row data needs to be passed to the hooks
+
+   Defaults to false
+   */
+   individualHooks?: boolean,
+   /**
+    * How many rows to update (only for mysql and mariadb)
+    */
+   limit?: number,
+   /**
+    * Transaction to run query under
+    */
+   transaction?: ?Transaction,
+   /**
+    * If true, the updatedAt timestamp will not be updated.
+    */
+   silent?: boolean,
+   ...
+  } & FieldsOptions<TAttributes> & LoggingOptions & ReturningOptions
+
+
+
+  /**
+   * Options used for Model.aggregate
+   */
+  declare export type AggregateOptions = {
+   /**
+    * A hash of search attributes.
+    */
+   where?: WhereOptions,
+   /**
+    * The type of the result. If `field` is a field in this Model, the default will be the type of that field,
+    * otherwise defaults to float.
+    */
+   dataType?: DataTypeAbstract | string,
+   /**
+    * Applies DISTINCT to the field being aggregated over
+    */
+   distinct?: boolean,
+   /**
+    * The transaction that the query should be executed under
+    */
+   transaction?: ?Transaction,
+   /**
+    * When `true`, the first returned value of `aggregateFunction` is cast to `dataType` and returned.
+    * If additional attributes are specified, along with `group` clauses, set `plain` to `false` to return all values of all returned rows.
+   Defaults to `true`
+   */
+   plain?: boolean,
+   ...
+  } & LoggingOptions
+
+
+
+  /**
+   * A Model represents a table in the database. Sometimes you might also see it referred to as model, or simply
+   * as factory. This class should _not_ be instantiated directly, it is created using `sequelize.define`, and
+  already created models can be loaded using `sequelize.import`
+  */
+  declare export class Model<TAttributes, TInitAttributes = TAttributes, TPlainAttributes = TAttributes> {
+    static init(attributes: DefineAttributes, options: DefineOptions<this>): this,
+
+    static QueryInterface: QueryInterface,
+
+    static QueryGenerator: any,
+
+    static sequelize: Sequelize,
+
+    sequelize: Sequelize,
+
+    /**
+     * The options this model was initialized with
+     */
+    static options: ResolvedDefineOptions<this>,
+
+    /**
+     * Remove attribute from model definition
+     * @param attribute
+     */
+    static removeAttribute(attribute: string): void,
+
+    /**
+     * Sync this Model to the DB, that is create the table. Upon success, the callback will be called with the
+     * model instance (this)
+     */
+    static sync(options?: SyncOptions): Promise<this>,
+
+    /**
+     * Drop the table represented by this Model
+     * @param options
+     */
+    static drop(options?: DropOptions): Promise<void>,
+
+    /**
+     * Apply a schema to this model. For postgres, this will actually place the schema in front of the table
+     * name
+    - `"schema"."tableName"`, while the schema will be prepended to the table name for mysql and
+    sqlite - `'schema.tablename'`.
+     * @param schema The name of the schema
+     * @param options
+    */
+    static schema(schema: string, options?: SchemaOptions): Class<this>,
+
+    /**
+     * Get the tablename of the model, taking schema into account. The method will return The name as a string
+     * if the model has no schema, or an object with `tableName`, `schema` and `delimiter` properties.
+     * @param options The hash of options from any query. You can use one model to access tables with matching
+    schemas by overriding `getTableName` and using custom key/values to alter the name of the table.
+    (eg.
+    subscribers_1, subscribers_2)
+     * @param options .logging=false A function that gets executed while running the query to log the sql.
+    */
+    static getTableName(options?: GetTableNameOptions): string | Object,
+
+    /**
+     * Add a new scope to the model. This is especially useful for adding scopes with includes, when the model you want to include is not available at the time this model is defined.
+     *
+    By default this will throw an error if a scope with that name already exists. Pass `override: true` in the options object to silence this error.
+     * @param  The name of the scope. Use `defaultScope` to override the default scope
+     * @param
+     * @param  *
+     * @param  .override=false]
+    */
+    static addScope(
+      name: string,
+      scope: AnyFindOptions | (...args: Array<any>) => AnyFindOptions,
+      options?: AddScopeOptions): void,
+
+    /**
+     * Apply a scope created in `define` to the model. First let's look at how to create scopes:
+     * ```js
+    var Model = sequelize.define('model', attributes, {
+       defaultScope: {
+       where: {
+         username: 'dan'
+       },
+       limit: 12
+       },
+       scopes: {
+       isALie: {
+         where: {
+         stuff: 'cake'
+         }
+       },
+       complexFunction: function(email, accessLevel) {
+         return {
+         where: {
+           email: {
+           $like: email
+           },
+           accesss_level {
+           $gte: accessLevel
+           }
+         }
+         }
+       }
+       }
+    })
+    ```
+    Now, since you defined a default scope, every time you do Model.find, the default scope is appended to
+    your query. Here's a couple of examples:
+    ```js
+    Model.findAll() // WHERE username = 'dan'
+    Model.findAll({ where: { age: { gt: 12 } } }) // WHERE age>12 AND username = 'dan'
+    ```
+
+    To invoke scope functions you can do:
+    ```js
+    Model.scope({ method: ['complexFunction' 'dan@sequelize.com', 42]}).findAll()
+    // WHERE email like 'dan@sequelize.com%' AND access_level>= 42
+    ```
+     * @return  Model A reference to the model, with the scope(s) applied. Calling scope again on the returned
+    model will clear the previous scope.
+    */
+    static scope(
+      options?: string | ScopeOptions | $ReadOnlyArray<string | ScopeOptions>): Class<this>,
+
+    /**
+     * Search for multiple instances.
+     *
+    __Simple search using AND and =__
+    ```js
+    Model.findAll({
+       where: {
+       attr1: 42,
+       attr2: 'cake'
+       }
+    })
+    ```
+    ```sql
+    WHERE attr1 = 42 AND attr2 = 'cake'
+    ```
+
+    __Using greater than, less than etc.__
+    ```js
+
+    Model.findAll({
+       where: {
+       attr1: {
+         gt: 50
+       },
+       attr2: {
+         lte: 45
+       },
+       attr3: {
+         in: [1,2,3]
+       },
+       attr4: {
+         ne: 5
+       }
+       }
+    })
+    ```
+    ```sql
+    WHERE attr1>50 AND attr2 <= 45 AND attr3 IN (1,2,3) AND attr4 != 5
+    ```
+    Possible options are: `$ne, $in, $not, $notIn, $gte, $gt, $lte, $lt, $like, $ilike/$iLike, $notLike,
+    $notILike, '..'/$between, '!..'/$notBetween, '&&'/$overlap, '@>'/$contains, '<@'/$contained`
+
+    __Queries using OR__
+    ```js
+    Model.findAll({
+       where: Sequelize.and(
+       { name: 'a project' },
+       Sequelize.or(
+         { id: [1,2,3] },
+         { id: { gt: 10 } }
+       )
+       )
+    })
+    ```
+    ```sql
+    WHERE name = 'a project' AND (id` IN (1,2,3) OR id>10)
+    ```
+
+    The success listener is called with an array of instances if the query succeeds.
+     * @see  {Sequelize#query}
+    */
+    static findAll<TCustomAttributes>(
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<this[]>,
+    static all<TCustomAttributes>(
+      optionz?: FindOptions<TAttributes & TCustomAttributes>): Promise<this[]>,
+
+    /**
+     * Search for a single instance by its primary key. This applies LIMIT 1, so the listener will
+     * always be called with a single instance.
+     */
+    static findById<TCustomAttributes>(
+      identifier?: number | string,
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<?this>,
+    static findByPrimary<TCustomAttributes>(
+      identifier?: number | string,
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<?this>,
+    static findByPk<TCustomAttributes>(
+      identifier?: number | string,
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<?this>,
+
+    /**
+     * Search for a single instance. This applies LIMIT 1, so the listener will always be called with a single
+     * instance.
+     */
+    static findOne<TCustomAttributes>(
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<?this>,
+    static find<TCustomAttributes>(
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<?this>,
+
+    /**
+     * Run an aggregation method on the specified field
+     * @param field The field to aggregate over. Can be a field name or *
+     * @param aggregateFunction The function to use for aggregation, e.g. sum, max etc.
+     * @param options Query options. See sequelize.query for full options
+     * @return  Returns the aggregate result cast to `options.dataType`, unless `options.plain` is false, in
+    which case the complete data result is returned.
+    */
+    static aggregate(
+      field: string,
+      aggregateFunction: string,
+      options?: AggregateOptions): Promise<Object>,
+
+    /**
+     * Count the number of records matching the provided where clause.
+     *
+    If you provide an `include` option, the number of matching associations will be counted instead.
+    */
+    static count(options?: CountOptions): Promise<number>,
+
+    /**
+     * Find all the rows matching your query, within a specified offset / limit, and get the total number of
+     * rows matching your query. This is very usefull for paging
+
+    ```js
+    Model.findAndCountAll({
+       where: ...,
+       limit: 12,
+       offset: 12
+    }).then(function (result) {
+       ...
+    })
+    ```
+    In the above example, `result.rows` will contain rows 13 through 24, while `result.count` will return
+    the
+    total number of rows that matched your query.
+
+    When you add includes, only those which are required (either because they have a where clause, or
+    because
+    `required` is explicitly set to true on the include) will be added to the count part.
+
+    Suppose you want to find all users who have a profile attached:
+    ```js
+    User.findAndCountAll({
+       include: [
+        { model: Profile, required: true}
+       ],
+       limit 3
+    });
+    ```
+    Because the include for `Profile` has `required` set it will result in an inner join, and only the users
+    who have a profile will be counted. If we remove `required` from the include, both users with and
+    without
+    profiles will be counted
+    */
+    static findAndCount<TCustomAttributes>(
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<{
+     rows: this[],
+     count: number,
+     ...
+    }>,
+    static findAndCountAll<TCustomAttributes>(
+      options?: FindOptions<TAttributes & TCustomAttributes>): Promise<{
+     rows: this[],
+     count: number,
+     ...
+    }>,
+
+    /**
+     * Find the maximum value of field
+     */
+    static max(field: string, options?: AggregateOptions): Promise<any>,
+
+    /**
+     * Find the minimum value of field
+     */
+    static min(field: string, options?: AggregateOptions): Promise<any>,
+
+    /**
+     * Find the sum of field
+     */
+    static sum(field: string, options?: AggregateOptions): Promise<number>,
+
+    /**
+     * Builds a new model instance. Values is an object of key value pairs, must be defined but can be empty.
+     */
+    static build(record?: TInitAttributes, options?: BuildOptions): this,
+
+    /**
+     * Undocumented bulkBuild
+     */
+    static bulkBuild(records: TInitAttributes[], options?: BuildOptions): this[],
+
+    /**
+     * Builds a new model instance and calls save on it.
+     */
+    static create(values?: TInitAttributes, options?: CreateOptions<TAttributes>): Promise<this>,
+
+    /**
+     * Find a row that matches the query, or build (but don't save) the row if none is found.
+     * The successfull result of the promise will be (instance, initialized) - Make sure to use .spread()
+     */
+    static findOrInitialize(
+      options: FindOrInitializeOptions<TInitAttributes>): Promise<[this, boolean]>,
+    static findOrBuild(
+      options: FindOrInitializeOptions<TInitAttributes>): Promise<[this, boolean]>,
+
+    /**
+     * Find a row that matches the query, or build and save the row if none is found
+     * The successful result of the promise will be (instance, created) - Make sure to use .spread()
+
+    If no transaction is passed in the `options` object, a new transaction will be created internally, to
+    prevent the race condition where a matching row is created by another connection after the find but
+    before the insert call. However, it is not always possible to handle this case in SQLite, specifically
+    if one transaction inserts and another tries to select before the first one has comitted. In this case,
+    an instance of sequelize.TimeoutError will be thrown instead. If a transaction is created, a savepoint
+    will be created instead, and any unique constraint violation will be handled internally.
+    */
+    static findOrCreate(
+      options: FindOrInitializeOptions<TInitAttributes>): Promise<[this, boolean]>,
+
+    /**
+     * A more performant findOrCreate that will not work under a transaction (at least not in postgres)
+     * Will execute a find call, if empty then attempt to create, if unique constraint then attempt to find again
+     */
+    static findCreateFind<TCustomAttributes>(
+      options: FindCreateFindOptions<TInitAttributes & TCustomAttributes>): Promise<[this, boolean]>,
+
+    /**
+     * Insert or update a single row. An update will be executed if a row which matches the supplied values on
+     * either the primary key or a unique key is found. Note that the unique index must be defined in your
+    sequelize model and not just in the table. Otherwise you may experience a unique constraint violation,
+    because sequelize fails to identify the row that should be updated.
+
+    *Implementation details:*
+
+    * MySQL - Implemented as a single query `INSERT values ON DUPLICATE KEY UPDATE values`
+    * PostgreSQL - Implemented as a temporary function with exception handling: INSERT EXCEPTION WHEN
+       unique_constraint UPDATE
+    * SQLite - Implemented as two queries `INSERT; UPDATE`. This means that the update is executed
+    regardless
+       of whether the row already existed or not
+
+    *Note* that SQLite returns undefined for created, no matter if the row was created or updated. This is
+    because SQLite always runs INSERT OR IGNORE + UPDATE, in a single query, so there is no way to know
+    whether the row was inserted or not.
+    */
+    static upsert(values: TInitAttributes, options?: UpsertOptions<TAttributes>): Promise<boolean>,
+    static insertOrUpdate(values: TInitAttributes, options?: UpsertOptions<TAttributes>): Promise<boolean>,
+
+    /**
+     * Create and insert multiple instances in bulk.
+     *
+    The success handler is passed an array of instances, but please notice that these may not completely
+    represent the state of the rows in the DB. This is because MySQL and SQLite do not make it easy to
+    obtain
+    back automatically generated IDs and other default values in a way that can be mapped to multiple
+    records. To obtain Instances for the newly created values, you will need to query for them again.
+     * @param records List of objects (key/value pairs) to create instances from
+    */
+    static bulkCreate(
+      records: TInitAttributes[],
+      options?: BulkCreateOptions<TAttributes>): Promise<this[]>,
+
+    /**
+     * Truncate all instances of the model. This is a convenient method for Model.destroy({ truncate: true }).
+     */
+    static truncate(options?: TruncateOptions): Promise<void>,
+
+    /**
+     * Delete multiple instances, or set their deletedAt timestamp to the current time if `paranoid` is enabled.
+     * @return  Promise<number> The number of destroyed rows
+     */
+    static destroy(options?: DestroyOptions): Promise<number>,
+
+    /**
+     * Restore multiple instances if `paranoid` is enabled.
+     */
+    static restore(options?: RestoreOptions): Promise<void>,
+
+    /**
+     * Update multiple instances that match the where options. The promise returns an array with one or two
+     * elements. The first element is always the number of affected rows, while the second element is the actual
+    affected rows (only supported in postgres with `options.returning` true.)
+    */
+    static update(
+      values: $Shape<TAttributes>,
+      options: UpdateOptions<TAttributes>): Promise<[number, this[]]>,
+
+    /**
+     * Run a describe query on the table. The result will be return to the listener as a hash of attributes and
+     * their types.
+     */
+    static describe(): Promise<Object>,
+
+    /**
+     * Unscope the model
+     */
+    static unscoped(): Class<this>,
+
+    /**
+     * Add a hook to the model
+     * @param hookType
+     * @param name Provide a name for the hook function. It can be used to remove the hook later or to order
+     hooks based on some sort of priority system in the future.
+     * @param fn The hook function
+     * @alias  hook
+     */
+    static addHook(hookType: string, name: string, fn: Function): Class<this>,
+    static addHook(hookType: string, fn: Function): Class<this>,
+    static hook(hookType: string, name: string, fn: Function): Class<this>,
+    static hook(hookType: string, fn: Function): Class<this>,
+
+    /**
+     * Remove hook from the model
+     * @param hookType
+     * @param name
+     */
+    static removeHook(hookType: string, name: string): Class<this>,
+
+    /**
+     * Check whether the model has any hooks of this type
+     * @param hookType
+     * @alias  hasHooks
+     */
+    static hasHook(hookType: string): boolean,
+    static hasHooks(hookType: string): boolean,
+
+    /**
+     * A hook that is run before validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static beforeValidate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static beforeValidate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static afterValidate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static afterValidate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static validationFailed(
+      name: string,
+      fn: AsyncFn3<this, Object, ValidationError>): void,
+    static validationFailed(fn: AsyncFn3<this, Object, ValidationError>): void,
+
+    /**
+     * A hook that is run before creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static beforeCreate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static beforeCreate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run after creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static afterCreate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static afterCreate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run before destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  beforeDelete
+     */
+    static beforeDestroy(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static beforeDestroy(fn: AsyncFn2<this, Object>): void,
+    static beforeDelete(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static beforeDelete(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run after destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  afterDelete
+     */
+    static afterDestroy(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static afterDestroy(fn: AsyncFn2<this, Object>): void,
+    static afterDelete(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static afterDelete(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run before updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static beforeUpdate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static beforeUpdate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run after updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static afterUpdate(
+      name: string,
+      fn: AsyncFn2<this, Object>): void,
+    static afterUpdate(fn: AsyncFn2<this, Object>): void,
+
+    /**
+     * A hook that is run before upserting
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static beforeUpsert(
+      name: string,
+      fn: AsyncFn2<TInitAttributes, Object>): void,
+    static beforeUpsert(fn: AsyncFn2<TInitAttributes, Object>): void,
+
+    /**
+     * A hook that is run after upserting
+     * @param name
+     * @param fn A callback function that is called with result of upsert(), options
+     */
+    static afterUpsert(
+      name: string,
+      fn: AsyncFn2<boolean | [this, boolean], Object>): void,
+    static afterUpsert(fn: AsyncFn2<boolean | [this, boolean], Object>): void,
+
+    /**
+     * A hook that is run before creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     */
+    static beforeBulkCreate(
+      name: string,
+      fn: AsyncFn2<this[], Object>): void,
+    static beforeBulkCreate(fn: AsyncFn2<this[], Object>): void,
+
+    /**
+     * A hook that is run after creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     * @name  afterBulkCreate
+     */
+    static afterBulkCreate(
+      name: string,
+      fn: AsyncFn2<this[], Object>): void,
+    static afterBulkCreate(fn: AsyncFn2<this[], Object>): void,
+
+    /**
+     * A hook that is run before destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  beforeBulkDelete
+     */
+    static beforeBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkDestroy(fn: AsyncFn1<Object>): void,
+    static beforeBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /* A hook that is run after destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  afterBulkDelete
+     */
+    static afterBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkDestroy(fn: AsyncFn1<Object>): void,
+    static afterBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static afterBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFind(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFind(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFindAfterExpandIncludeAll(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFindAfterExpandIncludeAll(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after all option parsing is complete
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFindAfterOptions(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFindAfterOptions(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after a find (select) query
+     * @param name
+     * @param fn A callback function that is called with instance(s), options
+     */
+    static afterFind(
+      name: string,
+      AsyncFn2<this | this[], Object>): void,
+    static afterFind(
+      AsyncFn2<this | this[], Object>): void,
+
+    /**
+     * A hook that is run before a define call
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static beforeDefine(
+      name: string,
+      fn: AsyncFn2<DefineAttributes, Object>): void,
+    static beforeDefine(fn: AsyncFn2<DefineAttributes, Object>): void,
+
+    /**
+     * A hook that is run after a define call
+     * @param name
+     * @param fn A callback function that is called with factory
+     */
+    static afterDefine(name: string, fn: AsyncFn1<Model<this, any>>): void,
+    static afterDefine(fn: AsyncFn1<Model<this, any>>): void,
+
+    /**
+     * A hook that is run before Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with config, options
+     */
+    static beforeInit(name: string, fn: AsyncFn2<Object, Object>): void,
+    static beforeInit(fn: AsyncFn2<Object, Object>): void,
+
+    /**
+     * A hook that is run after Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with sequelize
+     */
+    static afterInit(name: string, fn: AsyncFn1<Sequelize>): void,
+    static afterInit(fn: AsyncFn1<Sequelize>): void,
+
+    /**
+     * A hook that is run before Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    static beforeSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static beforeSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    static afterSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static afterSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run before sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    static beforeBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static beforeBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    static afterBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static afterBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * Creates an association between this (the source) and the provided target. The foreign key is added
+     * on the target.
+
+     Example: `User.hasOne(Profile)`. This will add userId to the profile table.
+     * @param target The model that will be associated with hasOne relationship
+     * @param options Options for the association
+     */
+    static hasOne<TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>>(
+      target: Class<Target>,
+      options?: AssociationOptionsHasOne): HasOne<this, TargetAttributes, TargetInitAttributes, Target>,
+
+    /**
+     * Creates an association between this (the source) and the provided target. The foreign key is added on the
+     * source.
+
+     Example: `Profile.belongsTo(User)`. This will add userId to the profile table.
+     * @param target The model that will be associated with hasOne relationship
+     * @param options Options for the association
+     */
+    static belongsTo<TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>>(
+      target: Class<Target>,
+      options?: AssociationOptionsBelongsTo): BelongsTo<this, TargetAttributes, TargetInitAttributes, Target>,
+
+    /**
+     * Create an association that is either 1:m or n:m.
+     *
+     ```js
+     // Create a 1:m association between user and project
+     User.hasMany(Project)
+     ```
+     ```js
+     // Create a n:m association between user and project
+     User.hasMany(Project)
+     Project.hasMany(User)
+     ```
+     By default, the name of the join table will be source+target, so in this case projectsusers. This can be
+     overridden by providing either a string or a Model as `through` in the options. If you use a through
+     model with custom attributes, these attributes can be set when adding / setting new associations in two
+     ways. Consider users and projects from before with a join table that stores whether the project has been
+     started yet:
+     ```js
+     var UserProjects = sequelize.define('userprojects', {
+         started: Sequelize.BOOLEAN
+      })
+     User.hasMany(Project, { through: UserProjects })
+     Project.hasMany(User, { through: UserProjects })
+     ```
+     ```js
+     jan.addProject(homework, { started: false }) // The homework project is not started yet
+     jan.setProjects([makedinner, doshopping], { started: true}) // Both shopping and dinner have been
+     started
+     ```
+
+     If you want to set several target instances, but with different attributes you have to set the
+     attributes on the instance, using a property with the name of the through model:
+
+     ```js
+     p1.userprojects {
+         started: true
+      }
+     user.setProjects([p1, p2], {started: false}) // The default value is false, but p1 overrides that.
+     ```
+
+     Similarily, when fetching through a join table with custom attributes, these attributes will be
+     available as an object with the name of the through model.
+     ```js
+     user.getProjects().then(function (projects) {
+         var p1 = projects[0]
+         p1.userprojects.started // Is this project started yet?
+      })
+     ```
+     * @param target The model that will be associated with hasOne relationship
+     * @param options Options for the association
+     */
+    static hasMany<TargetAttributes: Object, TargetInitAttributes: Object, Target: Model<TargetAttributes, TargetInitAttributes>>(
+      target: Class<Target>,
+      options?: AssociationOptionsHasMany): HasMany<this, TargetAttributes, TargetInitAttributes, Target>,
+
+    /**
+     * Create an N:M association with a join table
+     *
+     ```js
+     User.belongsToMany(Project)
+     Project.belongsToMany(User)
+     ```
+     By default, the name of the join table will be source+target, so in this case projectsusers. This can be
+     overridden by providing either a string or a Model as `through` in the options.
+
+     If you use a through model with custom attributes, these attributes can be set when adding / setting new
+     associations in two ways. Consider users and projects from before with a join table that stores whether
+     the project has been started yet:
+     ```js
+     var UserProjects = sequelize.define('userprojects', {
+         started: Sequelize.BOOLEAN
+      })
+     User.belongsToMany(Project, { through: UserProjects })
+     Project.belongsToMany(User, { through: UserProjects })
+     ```
+     ```js
+     jan.addProject(homework, { started: false }) // The homework project is not started yet
+     jan.setProjects([makedinner, doshopping], { started: true}) // Both shopping and dinner has been started
+     ```
+
+     If you want to set several target instances, but with different attributes you have to set the
+     attributes on the instance, using a property with the name of the through model:
+
+     ```js
+     p1.userprojects {
+         started: true
+      }
+     user.setProjects([p1, p2], {started: false}) // The default value is false, but p1 overrides that.
+     ```
+
+     Similarily, when fetching through a join table with custom attributes, these attributes will be
+     available as an object with the name of the through model.
+     ```js
+     user.getProjects().then(function (projects) {
+         var p1 = projects[0]
+         p1.userprojects.started // Is this project started yet?
+      })
+     ```
+     * @param target The model that will be associated with hasOne relationship
+     * @param options Options for the association
+     */
+    static belongsToMany<
+      TargetAttributes: Object,
+      TargetInitAttributes: Object,
+      Target: Model<TargetAttributes, TargetInitAttributes>,
+      ThroughAttributes: Object,
+      Through: Model<ThroughAttributes, any>
+    >(
+      target: Class<Target>,
+      options: AssociationOptionsBelongsToMany<Through>
+    ): BelongsToMany<
+      TAttributes, TInitAttributes, this,
+      TargetAttributes, TargetInitAttributes, Target,
+      ThroughAttributes, Through
+    >,
+
+    static getAssociations<Target: Model<any>>(model: Class<Target>): Array<Association<this, Target>>;
+    static getAssociationForAlias<Target: Model<any>>(model: Class<Target>, alias: ?string): ?Association<this, Target>;
+
+    static associations: { [name: string]: Association<this, any>, ... },
+    static tableName: string,
+    static rawAttributes: { [name: string]: Attribute, ... },
+    static tableAttributes: { [name: string]: Attribute, ... },
+    static attributes: { [name: string]: Attribute, ... },
+    static primaryKeys: { [name: string]: Attribute, ... },
+    static primaryKeyAttributes: Array<string>,
+    static primaryKeyAttribute: ?string,
+    static primaryKeyField?: string,
+    static uniqueKeys: { [idxName: string | false]: {
+     name: string | false,
+     column: string | false,
+     msg: ?string,
+     fields: Array<string>,
+     ...
+    }, ... },
+    static fieldRawAttributesMap: { [name: string]: string, ... },
+    static fieldAttributesMap: { [name: string]: string, ... },
+
+    Model: Class<this>,
+
+    sequelize: Sequelize,
+
+    /**
+     * Returns true if this instance has not yet been persisted to the database
+     */
+    isNewRecord: boolean,
+
+    /**
+     * Get an object representing the query for this instance, use with `options.where`
+     */
+    where(): Object,
+
+    /**
+     * Get the value of the underlying data value
+     */
+    getDataValue(key: $Keys<TAttributes>): any,
+
+    /**
+     * Update the underlying data value
+     */
+    setDataValue(key: $Keys<TAttributes>, value: any): void,
+
+    /**
+     * If no key is given, returns all values of the instance, also invoking virtual getters.
+     *
+     If key is given and a field or virtual getter is present for the key it will call that getter - else it
+     will return the value for key.
+     * @param options .plain If set to true, included instances will be returned as plain objects
+     */
+    get(options: {
+     plain: true,
+     raw?: boolean,
+     clone?: boolean,
+     ...
+    }): TPlainAttributes,
+    get(key: $Keys<TAttributes>, options?: {
+     plain?: boolean,
+     clone?: boolean,
+     raw?: boolean,
+     ...
+    }): any,
+    get(options?: {
+     plain?: boolean,
+     clone?: boolean,
+     raw?: boolean,
+     ...
+    }): TAttributes,
+
+    /**
+     * Set is used to update values on the instance (the sequelize representation of the instance that is,
+     * remember that nothing will be persisted before you actually call `save`). In its most basic form `set`
+     will update a value stored in the underlying `dataValues` object. However, if a custom setter function
+     is defined for the key, that function will be called instead. To bypass the setter, you can pass `raw:
+     true` in the options object.
+
+     If set is called with an object, it will loop over the object, and call set recursively for each key,
+     value pair. If you set raw to true, the underlying dataValues will either be set directly to the object
+     passed, or used to extend dataValues, if dataValues already contain values.
+
+     When set is called, the previous value of the field is stored and sets a changed flag(see `changed`).
+
+     Set can also be used to build instances for associations, if you have values for those.
+     When using set with associations you need to make sure the property key matches the alias of the
+     association while also making sure that the proper include options have been set (from .build() or
+     .find())
+
+     If called with a dot.seperated key on a JSON/JSONB attribute it will set the value nested and flag the
+     entire object as changed.
+     * @param options .raw If set to true, field and virtual setters will be ignored
+     * @param options .reset Clear all previously set data values
+     */
+    set(key: $Keys<TAttributes>, value: any, options?: InstanceSetOptions): this,
+    set(keys: $Shape<TAttributes>, options?: InstanceSetOptions): this,
+    setAttributes(key: $Keys<TAttributes>, value: any, options?: InstanceSetOptions): this,
+    setAttributes(keys: $Shape<TAttributes>, options?: InstanceSetOptions): this,
+
+    /**
+     * If changed is called with a string it will return a boolean indicating whether the value of that key in
+     * `dataValues` is different from the value in `_previousDataValues`.
+
+     If changed is called without an argument, it will return an array of keys that have changed.
+
+     If changed is called without an argument and no keys have changed, it will return `false`.
+     */
+    changed(key: $Keys<TAttributes>): boolean,
+    changed(): boolean | Array<$Keys<TAttributes>>,
+
+    /**
+     * Returns the previous value for key from `_previousDataValues`.
+     */
+    previous(key: $Keys<TAttributes>): any,
+
+    /**
+     * Validate this instance, and if the validation passes, persist it to the database.
+     *
+     On success, the callback will be called with this instance. On validation error, the callback will be
+     called with an instance of `Sequelize.ValidationError`. This error will have a property for each of the
+     fields for which validation failed, with the error message for that field.
+     */
+    save(options?: InstanceSaveOptions<TAttributes>): Promise<this>,
+
+    /**
+     * Refresh the current instance in-place, i.e. update the object with current data from the DB and return
+     * the same object. This is different from doing a `find(Instance.id)`, because that would create and
+     return a new instance. With this method, all references to the Instance are updated with the new data
+     and no new objects are created.
+     */
+    reload(options?: AnyFindOptions): Promise<this>,
+
+    /**
+     * Validate the attribute of this instance according to validation rules set in the model definition.
+     *
+     Emits null if and only if validation successful; otherwise an Error instance containing
+     { field name : [error msgs] } entries.
+     * @param options .skip An array of strings. All properties that are in this array will not be validated
+     */
+    validate(options?: { skip?: $Keys<TAttributes>[], ... }): Promise<ValidationError>,
+
+    /**
+     * This is the same as calling `set` and then calling `save`.
+     */
+    update(
+      key: $Keys<TAttributes>,
+      value: any,
+      options?: InstanceUpdateOptions<TAttributes>): Promise<this>,
+    update(keys: $Shape<TAttributes>, options?: InstanceUpdateOptions<TAttributes>): Promise<this>,
+    updateAttributes(
+      key: $Keys<TAttributes>,
+      value: any,
+      options?: InstanceUpdateOptions<TAttributes>): Promise<this>,
+    updateAttributes(keys: $Shape<TAttributes>, options?: InstanceUpdateOptions<TAttributes>): Promise<this>,
+
+    /**
+     * Destroy the row corresponding to this instance. Depending on your setting for paranoid, the row will
+     * either be completely deleted, or have its deletedAt timestamp set to the current time.
+     */
+    destroy(options?: InstanceDestroyOptions): Promise<void>,
+
+    /**
+     * Restore the row corresponding to this instance. Only available for paranoid models.
+     */
+    restore(options?: InstanceRestoreOptions): Promise<void>,
+
+    /**
+     * Increment the value of one or more columns. This is done in the database, which means it does not use
+     * the values currently stored on the Instance. The increment is done using a
+     ```sql
+     SET column = column + X
+     ```
+     query. To get the correct value after an increment into the Instance you should do a reload.
+
+     ```js
+     instance.increment('number') // increment number by 1
+     instance.increment(['number', 'count'], { by: 2 }) // increment number and count by 2
+     instance.increment({ answer: 42, tries: 1}, { by: 2 }) // increment answer by 42, and tries by 1.
+     // `by` is ignored, since each column has its own
+     // value
+     ```
+     * @param fields If a string is provided, that column is incremented by the value of `by` given in options.
+     If an array is provided, the same is true for each column.
+     If and object is provided, each column is incremented by the value given.
+     */
+    increment(
+      fields: $Keys<TAttributes> | $Keys<TAttributes>[] | { [key: $Keys<TAttributes>]: number, ... },
+      options?: InstanceIncrementDecrementOptions): Promise<this>,
+
+    /**
+     * Decrement the value of one or more columns. This is done in the database, which means it does not use
+     * the values currently stored on the Instance. The decrement is done using a
+     ```sql
+     SET column = column - X
+     ```
+     query. To get the correct value after an decrement into the Instance you should do a reload.
+
+     ```js
+     instance.decrement('number') // decrement number by 1
+     instance.decrement(['number', 'count'], { by: 2 }) // decrement number and count by 2
+     instance.decrement({ answer: 42, tries: 1}, { by: 2 }) // decrement answer by 42, and tries by 1.
+     // `by` is ignored, since each column has its own
+     // value
+     ```
+     * @param fields If a string is provided, that column is decremented by the value of `by` given in options.
+     If an array is provided, the same is true for each column.
+     If and object is provided, each column is decremented by the value given
+     */
+    decrement(
+      fields: $Keys<TAttributes> | $Keys<TAttributes>[] | { [key: $Keys<TAttributes>]: number, ... },
+      options?: InstanceIncrementDecrementOptions): Promise<this>,
+
+    /**
+     * Check whether all values of this and `other` Instance are the same
+     */
+    equals(other: Model<any>): boolean,
+
+    /**
+     * Check if this is equal to one of `others` by calling equals
+     */
+    equalsOneOf(others: Model<any>[]): boolean,
+
+    /**
+     * Convert the instance to a JSON representation. Proxies to calling `get` with no keys. This means get all
+     * values gotten from the DB, and apply all custom getters.
+     */
+    toJSON(): TPlainAttributes,
+  }
+
+
+
+  /**
+   * Most of the methods accept options and use only the logger property of the options. That's why the most used
+   * interface type for options in a method is separated here as another interface.
+   */
+  declare export type QueryInterfaceOptions = { /**
+   * A function that gets executed while running the query to log the sql.
+   */
+  logging?: boolean | Function, ... }
+
+  declare export type AddUniqueConstraintOptions = {
+   type: 'unique',
+   name?: string,
+   ...
+  }
+
+  declare export type AddDefaultConstraintOptions = {
+   type: 'default',
+   name?: string,
+   defaultValue?: any,
+   ...
+  }
+
+  declare export type AddCheckConstraintOptions = {
+   type: 'check',
+   name?: string,
+   where?: WhereOptions,
+   ...
+  }
+
+  declare export type AddPrimaryKeyConstraintOptions = {
+   type: 'primary key',
+   name?: string,
+   ...
+  }
+
+  declare export type AddForeignKeyConstraintOptions = {
+   type: 'foreign key',
+   name?: string,
+   references?: {
+    table: string,
+    field: string,
+    ...
+   },
+   onDelete: string,
+   onUpdate: string,
+   ...
+  }
+
+  declare export type AddConstraintOptions =
+    AddUniqueConstraintOptions |
+    AddDefaultConstraintOptions |
+    AddCheckConstraintOptions |
+    AddPrimaryKeyConstraintOptions |
+    AddForeignKeyConstraintOptions;
+
+
+  /**
+   * The interface that Sequelize uses to talk to all databases.
+   *
+  This interface is available through sequelize.QueryInterface. It should not be commonly used, but it's
+  referenced anyway, so it can be used.
+  */
+  declare export interface QueryInterface {
+    /**
+     * Returns the dialect-specific sql generator.
+     *
+    We don't have a definition for the QueryGenerator, because I doubt it is commonly in use separately.
+    */
+    QueryGenerator: any,
+
+    /**
+     * Returns the current sequelize instance.
+     */
+    sequelize: Sequelize,
+
+    /**
+     * Queries the schema (table list).
+     * @param schema The schema to query. Applies only to Postgres.
+     */
+    createSchema(schema?: string, options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Drops the specified schema (table).
+     * @param schema The schema to query. Applies only to Postgres.
+     */
+    dropSchema(schema?: string, options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Drops all tables.
+     */
+    dropAllSchemas(options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Queries all table names in the database.
+     * @param options
+     */
+    showAllSchemas(options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Return database version
+     */
+    databaseVersion(options?: QueryInterfaceOptions): Promise<string>,
+
+    /**
+     * Creates a table with specified attributes.
+     * @param tableName Name of table to create
+     * @param attributes Hash of attributes, key is attribute name, value is data type
+     * @param options Query options.
+     */
+    createTable(
+      tableName: string | {
+       schema?: string,
+       tableName?: string,
+       ...
+      },
+      attributes: DefineAttributes,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Drops the specified table.
+     * @param tableName Table name.
+     * @param options Query options, particularly "force".
+     */
+    dropTable(tableName: string, options?: QueryOptions): Promise<void>,
+
+    /**
+     * Drops all tables.
+     * @param options
+     */
+    dropAllTables(options?: QueryOptions): Promise<void>,
+
+    /**
+     * Drops all defined enums
+     * @param options
+     */
+    dropAllEnums(options?: QueryOptions): Promise<void>,
+
+    /**
+     * Renames a table
+     */
+    renameTable(
+      before: string,
+      after: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Returns all tables
+     */
+    showAllTables(options?: QueryOptions): Promise<string[]>,
+
+    /**
+     * Describe a table
+     */
+    describeTable(
+      tableName: string | {
+       schema?: string,
+       tableName?: string,
+       ...
+      },
+      options?: string | {
+       schema?: string,
+       schemaDelimeter?: string,
+       logging?: boolean | Function,
+       ...
+      }): Promise<Object>,
+
+    /**
+     * Adds a new column to a table
+     */
+    addColumn(
+      table: string,
+      key: string,
+      attribute: DefineAttributeColumnOptions | DataTypeAbstract,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Removes a column from a table
+     */
+    removeColumn(
+      table: string,
+      attribute: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Changes a column
+     */
+    changeColumn(
+      tableName: string | {
+       schema?: string,
+       tableName?: string,
+       ...
+      },
+      attributeName: string,
+      dataTypeOrOptions?: string | DataTypeAbstract | DefineAttributeColumnOptions,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Renames a column
+     */
+    renameColumn(
+      tableName: string | {
+       schema?: string,
+       tableName?: string,
+       ...
+      },
+      attrNameBefore: string,
+      attrNameAfter: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Adds a new index to a table
+     */
+    addIndex(
+      tableName: string | Object,
+      options?: {
+       fields: Array<string>,
+       unique?: boolean,
+       using?: string,
+       type?: IndexType,
+       name?: string,
+       where?: WhereOptions<any>,
+       ...
+      }
+    ): Promise<void>,
+
+    /**
+     * Shows the index of a table
+     */
+    showIndex(tableName: string | Object, options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Put a name to an index
+     */
+    nameIndexes(indexes: string[], rawTablename: string): Promise<void>,
+
+    /**
+     * Returns all foreign key constraints of a table
+     */
+    getForeignKeysForTables(tableNames: string, options?: QueryInterfaceOptions): Promise<Object>,
+
+    /**
+     * Removes an index of a table
+     */
+    removeIndex(
+      tableName: string,
+      indexNameOrAttributes: string[] | string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Adds constraints to a table
+     */
+    addConstraint(
+      tableName: string,
+      attributes: string[],
+      options?: AddConstraintOptions | QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Removes constraints from a table
+     */
+    removeConstraint(
+      tableName: string,
+      constraintName: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Inserts a new record
+     */
+    insert(
+      instance: Model<any>,
+      tableName: string,
+      values: Object,
+      options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Inserts or Updates a record in the database
+     */
+    upsert(
+      tableName: string,
+      values: Object,
+      updateValues: Object,
+      model: Class<Model<any>>,
+      options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Inserts multiple records at once
+     */
+    bulkInsert(
+      tableName: string,
+      records: Object[],
+      options?: QueryOptions,
+      attributes?: string[] | string): Promise<Object>,
+
+    /**
+     * Updates a row
+     */
+    update(
+      instance: Model<any>,
+      tableName: string,
+      values: Object,
+      identifier: Object,
+      options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Updates multiple rows at once
+     */
+    bulkUpdate(
+      tableName: string,
+      values: Object,
+      identifier: Object,
+      options?: QueryOptions,
+      attributes?: string[] | string): Promise<Object>,
+
+    /**
+     * Deletes a row
+     */
+    delete(
+      instance: Model<any>,
+      tableName: string,
+      identifier: Object,
+      options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Deletes multiple rows at once
+     */
+    bulkDelete(
+      tableName: string,
+      identifier: Object,
+      options?: QueryOptions,
+      model?: Class<Model<any>>): Promise<Object>,
+
+    /**
+     * Returns selected rows
+     */
+    select(
+      model: Class<Model<any>>,
+      tableName: string,
+      options?: QueryOptions): Promise<Object[]>,
+
+    /**
+     * Increments a row value
+     */
+    increment(
+      instance: Model<any>,
+      tableName: string,
+      values: Object,
+      identifier: Object,
+      options?: QueryOptions): Promise<Object>,
+
+    /**
+     * Selects raw without parsing the string into an object
+     */
+    rawSelect(
+      tableName: string,
+      options: QueryOptions,
+      attributeSelector: string | string[],
+      model?: Class<Model<any>>): Promise<string[]>,
+
+    /**
+     * Postgres only. Creates a trigger on specified table to call the specified function with supplied
+     * parameters.
+     */
+    createTrigger(
+      tableName: string,
+      triggerName: string,
+      timingType: string,
+      fireOnArray: any[],
+      functionName: string,
+      functionParams: any[],
+      optionsArray: string[],
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Postgres only. Drops the specified trigger.
+     */
+    dropTrigger(
+      tableName: string,
+      triggerName: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Postgres only. Renames a trigger
+     */
+    renameTrigger(
+      tableName: string,
+      oldTriggerName: string,
+      newTriggerName: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Postgres only. Create a function
+     */
+    createFunction(
+      functionName: string,
+      params: any[],
+      returnType: string,
+      language: string,
+      body: string,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Postgres only. Drops a function
+     */
+    dropFunction(
+      functionName: string,
+      params: any[],
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Postgres only. Rename a function
+     */
+    renameFunction(
+      oldFunctionName: string,
+      params: any[],
+      newFunctionName: string,
+      options?: QueryInterfaceOptions): Promise<void>,
+
+    /**
+     * Escape an identifier (e.g. a table or attribute name). If force is true, the identifier will be quoted
+     * even if the `quoteIdentifiers` option is false.
+     */
+    quoteIdentifier(identifier: string, force: boolean): string,
+
+    /**
+     * Escape a table name
+     */
+    quoteTable(identifier: string): string,
+
+    /**
+     * Split an identifier into .-separated tokens and quote each part. If force is true, the identifier will be
+     * quoted even if the `quoteIdentifiers` option is false.
+     */
+    quoteIdentifiers(identifiers: string, force: boolean): string,
+
+    /**
+     * Escape a value (e.g. a string, number or date)
+     */
+    escape(value?: string | number | Date): string,
+
+    /**
+     * Set option for autocommit of a transaction
+     */
+    setAutocommit(
+      transaction: Transaction,
+      value: boolean,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Set the isolation level of a transaction
+     */
+    setIsolationLevel(
+      transaction: Transaction,
+      value: string,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Begin a new transaction
+     */
+    startTransaction(
+      transaction: Transaction,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Defer constraints
+     */
+    deferConstraints(
+      transaction: Transaction,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Commit an already started transaction
+     */
+    commitTransaction(
+      transaction: Transaction,
+      options?: QueryOptions): Promise<void>,
+
+    /**
+     * Rollback ( revert ) a transaction that has'nt been commited
+     */
+    rollbackTransaction(
+      transaction: Transaction,
+      options?: QueryOptions): Promise<void>
+  }
+
+  declare export type QueryTypes = {
+   SELECT: string,
+   INSERT: string,
+   UPDATE: string,
+   BULKUPDATE: string,
+   BULKDELETE: string,
+   DELETE: string,
+   UPSERT: string,
+   VERSION: string,
+   SHOWTABLES: string,
+   SHOWINDEXES: string,
+   DESCRIBE: string,
+   RAW: string,
+   FOREIGNKEYS: string,
+   ...
+  }
+
+
+  /**
+   * General column options
+   * @see  Define
+   * @see  AssociationForeignKeyOptions
+   */
+  declare export type ColumnOptions = {
+   /**
+    * If false, the column will have a NOT NULL constraint, and a not null validation will be run before an
+    * instance is saved.
+    */
+   allowNull?: boolean,
+   /**
+    * If set, sequelize will map the attribute name to a different name in the database
+    */
+   field?: string,
+   /**
+    * A literal default value, a JavaScript function, or an SQL function (see `sequelize.fn`)
+    */
+   defaultValue?: any,
+   ...
+  }
+
+
+  /**
+   * References options for the column's attributes
+   * @see  AttributeColumnOptions
+   */
+  declare export type DefineAttributeColumnReferencesOptions = {
+   /**
+    * If this column references another table, provide it here as a Model, or a string
+    */
+   model: string | Class<Model<any>>,
+   /**
+    * The column of the foreign table that this column references
+    */
+   key?: string,
+   /**
+    * When to check for the foreign key constraing
+    *
+   PostgreSQL only
+   */
+   deferrable?: DeferrableInitiallyDeferred |
+   DeferrableInitiallyImmediate |
+   DeferrableNot |
+   DeferrableSetDeferred |
+   DeferrableSetImmediate,
+   ...
+  }
+
+
+  /**
+   * Column options for the model schema attributes
+   * @see  Attributes
+   */
+  declare export type DefineAttributeColumnOptions = {
+   /**
+    * A string or a data type
+    */
+   type: string | DataTypeAbstract,
+   /**
+    * If true, the column will get a unique constraint. If a string is provided, the column will be part of a
+    * composite unique index. If multiple columns have the same string, they will be part of the same unique
+   index
+   */
+   unique?: boolean | string | {
+    name: string,
+    msg: string,
+    ...
+   },
+   /**
+    * Primary key flag
+    */
+   primaryKey?: boolean,
+   /**
+    * Is this field an auto increment field
+    */
+   autoIncrement?: boolean,
+   /**
+    * Comment for the database
+    */
+   comment?: string,
+   /**
+    * An object with reference configurations
+    */
+   references?: string | Model<any> | DefineAttributeColumnReferencesOptions,
+   /**
+    * What should happen when the referenced key is updated. One of CASCADE, RESTRICT, SET DEFAULT, SET NULL or
+    * NO ACTION
+    */
+   onUpdate?: string,
+   /**
+    * What should happen when the referenced key is deleted. One of CASCADE, RESTRICT, SET DEFAULT, SET NULL or
+    * NO ACTION
+    */
+   onDelete?: string,
+   /**
+    * Provide a custom getter for this column. Use `this.getDataValue(String)` to manipulate the underlying
+    * values.
+    */
+   get?: () => any,
+   /**
+    * Provide a custom setter for this column. Use `this.setDataValue(String, Value)` to manipulate the
+    * underlying values.
+    */
+   set?: (val: any) => void,
+   /**
+    * An object of validations to execute for this column every time the model is saved. Can be either the
+    * name of a validation provided by validator.js, a validation function provided by extending validator.js
+   (see the
+   `DAOValidator` property for more details), or a custom validation function. Custom validation functions
+   are called with the value of the field, and can possibly take a second callback argument, to signal that
+   they are asynchronous. If the validator is sync, it should throw in the case of a failed validation, it
+   it is async, the callback should be called with the error text.
+   */
+   validate?: DefineValidateOptions,
+   /**
+    * Usage in object notation
+    *
+   ```js
+   sequelize.define('model', {
+      states: {
+        type:   Sequelize.ENUM,
+        values: ['active', 'pending', 'deleted']
+      }
+      })
+   ```
+   */
+   values?: string[],
+   ...
+  } & ColumnOptions
+
+
+
+  /**
+   * Interface for Attributes provided for a column
+   * @see  Sequelize.define
+   */
+  declare export type DefineAttributes = { [name: string]: string | DataTypeAbstract | DefineAttributeColumnOptions, ... }
+
+
+  /**
+   * Interface for query options
+   * @see  Options
+   */
+  declare export type QueryOptions = {
+   /**
+    * If true, sequelize will not try to format the results of the query, or build an instance of a model from
+    * the result
+    */
+   raw?: boolean,
+   /**
+    * The type of query you are executing. The query type affects how results are formatted before they are
+    * passed back. The type is a string, but `Sequelize.QueryTypes` is provided as convenience shortcuts.
+    */
+   type?: string,
+   /**
+    * If true, transforms objects with `.` separated property names into nested objects using
+    * [dottie.js](https://github.com/mickhansen/dottie.js). For example { 'user.username': 'john' } becomes
+   { user: { username: 'john' }}. When `nest` is true, the query type is assumed to be `'SELECT'`,
+   unless otherwise specified
+
+   Defaults to false
+   */
+   nest?: boolean,
+   /**
+    * Sets the query type to `SELECT` and return a single row
+    */
+   plain?: boolean,
+   /**
+    * Either an object of named parameter replacements in the format `:param` or an array of unnamed
+    * replacements to replace `?` in your SQL.
+    */
+   replacements?: Object | $ReadOnlyArray<string | number | boolean | Date>,
+   /**
+    * Either an object of named bind parameter in the format `$param` or an array of unnamed
+    * bind parameter to replace `$1`, `$2`, ... in your SQL.
+    */
+   bind?: Object | $ReadOnlyArray<string | number | boolean | Date>,
+   /**
+    * Force the query to use the write pool, regardless of the query type.
+    *
+   Defaults to false
+   */
+   useMaster?: boolean,
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: boolean | Function,
+   /**
+    * A sequelize instance used to build the return instance
+    */
+   instance?: Model<any>,
+   /**
+    * A sequelize model used to build the returned model instances (used to be called callee)
+    */
+   model?: Class<Model<any,
+   any>>,
+   /**
+    * Set of flags that control when a query is automatically retried.
+    */
+   retry?: RetryOptions,
+   /**
+    * If false do not prepend the query with the search_path (Postgres only)
+    */
+   supportsSearchPath?: boolean,
+   /**
+    * Map returned fields to model's fields if `options.model` or `options.instance` is present.
+    * Mapping will occur before building the model instance.
+    */
+   mapToModel?: boolean,
+   fieldMap?: { [key: string]: string, ... },
+   ...
+  } & SearchPathOptions & ReturningOptions
+
+
+
+  /**
+   * Model validations, allow you to specify format/content/inheritance validations for each attribute of the
+   * model.
+
+  Validations are automatically run on create, update and save. You can also call validate() to manually
+  validate an instance.
+
+  The validations are implemented by validator.js.
+  */
+  declare export type DefineValidateOptions = {
+   [name: string]: any,
+   /**
+    * is: ["^[a-z]+$",'i'] // will only allow letters
+    * is: /^[a-z]+$/i    // same as the previous example using real RegExp
+    */
+   is?: string | $ReadOnlyArray<string | RegExp>| RegExp | {
+    msg: string,
+    args: string | $ReadOnlyArray<string | RegExp>| RegExp,
+    ...
+   },
+   /**
+    * not: ["[a-z]",'i']  // will not allow letters
+    */
+   not?: string | $ReadOnlyArray<string | RegExp>| RegExp | {
+    msg: string,
+    args: string | $ReadOnlyArray<string | RegExp>| RegExp,
+    ...
+   },
+   /**
+    * checks for email format (foo@bar.com)
+    */
+   isEmail?: boolean | { msg: string, ... },
+   /**
+    * checks for url format (http://foo.com)
+    */
+   isUrl?: boolean | { msg: string, ... },
+   /**
+    * checks for IPv4 (129.89.23.1) or IPv6 format
+    */
+   isIP?: boolean | { msg: string, ... },
+   /**
+    * checks for IPv4 (129.89.23.1)
+    */
+   isIPv4?: boolean | { msg: string, ... },
+   /**
+    * checks for IPv6 format
+    */
+   isIPv6?: boolean | { msg: string, ... },
+   /**
+    * will only allow letters
+    */
+   isAlpha?: boolean | { msg: string, ... },
+   /**
+    * will only allow alphanumeric characters, so "_abc" will fail
+    */
+   isAlphanumeric?: boolean | { msg: string, ... },
+   /**
+    * will only allow numbers
+    */
+   isNumeric?: boolean | { msg: string, ... },
+   /**
+    * checks for valid integers
+    */
+   isInt?: boolean | { msg: string, ... },
+   /**
+    * checks for valid floating point numbers
+    */
+   isFloat?: boolean | { msg: string, ... },
+   /**
+    * checks for any numbers
+    */
+   isDecimal?: boolean | { msg: string, ... },
+   /**
+    * checks for lowercase
+    */
+   isLowercase?: boolean | { msg: string, ... },
+   /**
+    * checks for uppercase
+    */
+   isUppercase?: boolean | { msg: string, ... },
+   /**
+    * won't allow null
+    */
+   notNull?: boolean | { msg: string, ... },
+   /**
+    * only allows null
+    */
+   isNull?: boolean | { msg: string, ... },
+   /**
+    * don't allow empty strings
+    */
+   notEmpty?: boolean | { msg: string, ... },
+   /**
+    * only allow a specific value
+    */
+   equals?: string | { msg: string, ... },
+   /**
+    * force specific substrings
+    */
+   contains?: string | { msg: string, ... },
+   /**
+    * check the value is not one of these
+    */
+   notIn?: string[][] | {
+    msg: string,
+    args: string[][],
+    ...
+   },
+   /**
+    * check the value is one of these
+    */
+   isIn?: string[][] | {
+    msg: string,
+    args: string[][],
+    ...
+   },
+   /**
+    * don't allow specific substrings
+    */
+   notContains?: string[] | string | {
+    msg: string,
+    args: string[] | string,
+    ...
+   },
+   /**
+    * only allow values with length between 2 and 10
+    */
+   len?: [number, number] | {
+    msg: string,
+    args: [number, number],
+    ...
+   },
+   /**
+    * only allow uuids
+    */
+   isUUID?: 3 |
+   4 |
+   5 |
+   'all' |
+   {
+    msg: string,
+    args: number,
+    ...
+   },
+   /**
+    * only allow date strings
+    */
+   isDate?: boolean | {
+    msg: string,
+    args: boolean,
+    ...
+   },
+   /**
+    * only allow date strings after a specific date
+    */
+   isAfter?: string | {
+    msg: string,
+    args: string,
+    ...
+   },
+   /**
+    * only allow date strings before a specific date
+    */
+   isBefore?: string | {
+    msg: string,
+    args: string,
+    ...
+   },
+   /**
+    * only allow values
+    */
+   max?: number | {
+    msg: string,
+    args: number,
+    ...
+   },
+   /**
+    * only allow values>= 23
+    */
+   min?: number | {
+    msg: string,
+    args: number,
+    ...
+   },
+   /**
+    * only allow arrays
+    */
+   isArray?: boolean | {
+    msg: string,
+    args: boolean,
+    ...
+   },
+   /**
+    * check for valid credit card numbers
+    */
+   isCreditCard?: boolean | {
+    msg: string,
+    args: boolean,
+    ...
+   },
+   ...
+  }
+
+  declare export type IndexType = 'UNIQUE' | 'FULLTEXT' | 'SPATIAL'
+
+  declare export type DefineIndexOptions = {
+   /**
+    * The index type
+    */
+   indicesType?: IndexType,
+   /**
+    * The name of the index. Default is __
+    */
+   indexName?: string,
+   /**
+    * For FULLTEXT columns set your parser
+    */
+   parser?: string,
+   /**
+    * Set a type for the index, e.g. BTREE. See the documentation of the used dialect
+    */
+   indexType?: string,
+   /**
+    * A function that receives the sql query, e.g. console.log
+    */
+   logging?: Function,
+   /**
+    * A hash of attributes to limit your index(Filtered Indexes - MSSQL & PostgreSQL only)
+    */
+   where?: WhereOptions,
+   ...
+  }
+
+  declare export type IndexMethod = 'BTREE' | 'HASH' | 'GIST' | 'GIN'
+
+  /**
+   * Interface for indexes property in DefineOptions
+   * @see  DefineOptions
+   */
+  declare export type DefineIndexesOptions = {
+   /**
+    * The name of the index. Defaults to model name + _ + fields concatenated
+    */
+   name?: string,
+   /**
+    * Index type. Only used by mysql. One of `UNIQUE`, `FULLTEXT` and `SPATIAL`
+    */
+   index?: IndexType,
+   /**
+    * The method to create the index by (`USING` statement in SQL). BTREE and HASH are supported by mysql and
+    * postgres, and postgres additionally supports GIST and GIN.
+    */
+   method?: IndexMethod,
+   /**
+    * Should the index by unique? Can also be triggered by setting type to `UNIQUE`
+    *
+   Defaults to false
+   */
+   unique?: boolean,
+   /**
+    * PostgreSQL will build the index without taking any write locks. Postgres only
+    *
+   Defaults to false
+   */
+   concurrently?: boolean,
+   /**
+    * An array of the fields to index. Each field can either be a string containing the name of the field,
+    * a sequelize object (e.g `sequelize.fn`), or an object with the following attributes: `attribute`
+   (field name), `length` (create a prefix index of length chars), `order` (the direction the column
+   should be sorted in), `collate` (the collation (sort order) for the column)
+   */
+   fields?: $ReadOnlyArray<string | fn | {
+    attribute: string,
+    length: number,
+    order: string,
+    collate: string,
+    ...
+   }>,
+   /**
+    * Method the index should use, for example 'gin' index.
+    */
+   using?: string,
+   /**
+    * Operator that should be used by gin index, see Built-in GIN Operator Classes
+    */
+   operator?: string,
+   /**
+    * Condition for partioal index
+    */
+   where?: WhereOptions,
+   ...
+  }
+
+
+  /**
+   * Interface for name property in DefineOptions
+   * @see  DefineOptions
+   */
+  declare export type DefineNameOptions = {
+   /**
+    * Singular model name
+    */
+   singular?: string,
+   /**
+    * Plural model name
+    */
+   plural?: string,
+   ...
+  }
+
+
+  /**
+   * Interface for getterMethods in DefineOptions
+   * @see  DefineOptions
+   */
+  declare export type DefineGetterMethodsOptions = { [name: string]: () => any, ... }
+
+
+  /**
+   * Interface for setterMethods in DefineOptions
+   * @see  DefineOptions
+   */
+  declare export type DefineSetterMethodsOptions = { [name: string]: (val: any) => void, ... }
+
+
+  /**
+   * Interface for Define Scope Options
+   * @see  DefineOptions
+   */
+  declare export type DefineScopeOptions = { [scopeName: string]: AnyFindOptions | (...args: Array<any>) => AnyFindOptions, ... }
+
+
+  /**
+   * Options for model definition
+   * @see  Sequelize.define
+   */
+  declare export type DefineOptions<TInstance: Model<any>> = {
+   /**
+    * Define the default search scope to use for this model. Scopes have the same form as the options passed to
+    * find / findAll.
+    */
+   defaultScope?: AnyFindOptions,
+   /**
+    * More scopes, defined in the same way as defaultScope above. See `Model.scope` for more information about
+    * how scopes are defined, and what you can do with them
+    */
+   scopes?: DefineScopeOptions,
+   /**
+    * Don't persits null values. This means that all columns with null values will not be saved.
+    */
+   omitNull?: boolean,
+   /**
+    * Adds createdAt and updatedAt timestamps to the model. Default true.
+    */
+   timestamps?: boolean,
+   /**
+    * Calling destroy will not delete the model, but instead set a deletedAt timestamp if this is true. Needs
+    * timestamps=true to work. Default false.
+    */
+   paranoid?: boolean,
+   /**
+    * Converts all camelCased columns to underscored if true. Default false.
+    */
+   underscored?: boolean,
+   /**
+    * Converts camelCased model names to underscored tablenames if true. Default false.
+    */
+   underscoredAll?: boolean,
+   /**
+    * Indicates if the model's table has a trigger associated with it. Default false.
+    */
+   hasTrigger?: boolean,
+   /**
+    * If freezeTableName is true, sequelize will not try to alter the DAO name to get the table name.
+    * Otherwise, the dao name will be pluralized. Default false.
+    */
+   freezeTableName?: boolean,
+   /**
+    * An object with two attributes, `singular` and `plural`, which are used when this model is associated to
+    * others.
+    */
+   name?: DefineNameOptions,
+   /**
+    * Indexes for the provided database table
+    */
+   indexes?: DefineIndexesOptions[],
+   /**
+    * Override the name of the createdAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   createdAt?: string | boolean,
+   /**
+    * Override the name of the deletedAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   deletedAt?: string | boolean,
+   /**
+    * Override the name of the updatedAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   updatedAt?: string | boolean,
+   /**
+    * Defaults to pluralized model name, unless freezeTableName is true, in which case it uses model name
+    * verbatim
+    */
+   tableName?: string,
+   /**
+    * Provide getter functions that work like those defined per column. If you provide a getter method with
+    * the
+   same name as a column, it will be used to access the value of that column. If you provide a name that
+   does not match a column, this function will act as a virtual getter, that can fetch multiple other
+   values
+   */
+   getterMethods?: DefineGetterMethodsOptions,
+   /**
+    * Provide setter functions that work like those defined per column. If you provide a setter method with
+    * the
+   same name as a column, it will be used to update the value of that column. If you provide a name that
+   does not match a column, this function will act as a virtual setter, that can act on and set other
+   values, but will not be persisted
+   */
+   setterMethods?: DefineSetterMethodsOptions,
+   /**
+    * Provide functions that are added to each instance (DAO). If you override methods provided by sequelize,
+    * you can access the original method using `this.constructor.super_.prototype`, e.g.
+   `this.constructor.super_.prototype.toJSON.apply(this, arguments)`
+   */
+   instanceMethods?: Object,
+   /**
+    * Provide functions that are added to the model (Model). If you override methods provided by sequelize,
+    * you can access the original method using `this.constructor.prototype`, e.g.
+   `this.constructor.prototype.find.apply(this, arguments)`
+   */
+   classMethods?: Object,
+   schema?: string,
+   /**
+    * You can also change the database engine, e.g. to MyISAM. InnoDB is the default.
+    */
+   engine?: string,
+   charset?: string,
+   /**
+    * Finaly you can specify a comment for the table in MySQL and PG
+    */
+   comment?: string,
+   collate?: string,
+   /**
+    * Set the initial AUTO_INCREMENT value for the table in MySQL.
+    */
+   initialAutoIncrement?: string,
+   /**
+    * An object of hook function that are called before and after certain lifecycle events.
+    * The possible hooks are: beforeValidate, afterValidate, beforeBulkCreate, beforeBulkDestroy,
+   beforeBulkUpdate, beforeCreate, beforeDestroy, beforeUpdate, afterCreate, afterDestroy, afterUpdate,
+   afterBulkCreate, afterBulkDestory and afterBulkUpdate. See Hooks for more information about hook
+   functions and their signatures. Each property can either be a function, or an array of functions.
+   */
+   hooks?: HooksDefineOptions<TInstance>,
+   /**
+    * An object of model wide validations. Validations have access to all model values via `this`. If the
+    * validator function takes an argument, it is asumed to be async, and is called with a callback that
+   accepts an optional error.
+   */
+   validate?: DefineValidateOptions,
+   /**
+    * Enable optimistic locking.  When enabled, sequelize will add a version count attribute
+    * to the model and throw an OptimisticLockingError error when stale instances are saved.
+   Set to true or a string with the attribute name you want to use to enable.
+   */
+   version?: boolean | string,
+   ...
+  }
+
+  /**
+   * @see  Model.options
+   */
+  declare export type ResolvedDefineOptions<TInstance: Model<any>> = {
+   /**
+    * Define the default search scope to use for this model. Scopes have the same form as the options passed to
+    * find / findAll.
+    */
+   defaultScope: AnyFindOptions,
+   /**
+    * More scopes, defined in the same way as defaultScope above. See `Model.scope` for more information about
+    * how scopes are defined, and what you can do with them
+    */
+   scopes: DefineScopeOptions,
+   /**
+    * Don't persits null values. This means that all columns with null values will not be saved.
+    */
+   omitNull: boolean,
+   /**
+    * Adds createdAt and updatedAt timestamps to the model. Default true.
+    */
+   timestamps: boolean,
+   /**
+    * Calling destroy will not delete the model, but instead set a deletedAt timestamp if this is true. Needs
+    * timestamps=true to work. Default false.
+    */
+   paranoid: boolean,
+   /**
+    * Converts all camelCased columns to underscored if true. Default false.
+    */
+   underscored: boolean,
+   /**
+    * Converts camelCased model names to underscored tablenames if true. Default false.
+    */
+   underscoredAll: boolean,
+   /**
+    * Indicates if the model's table has a trigger associated with it. Default false.
+    */
+   hasTrigger?: boolean,
+   /**
+    * If freezeTableName is true, sequelize will not try to alter the DAO name to get the table name.
+    * Otherwise, the dao name will be pluralized. Default false.
+    */
+   freezeTableName: boolean,
+   /**
+    * An object with two attributes, `singular` and `plural`, which are used when this model is associated to
+    * others.
+    */
+   name: {
+    singular: string,
+    plural: string,
+    ...
+   },
+   /**
+    * Indexes for the provided database table
+    */
+   indexes: DefineIndexesOptions[],
+   /**
+    * Override the name of the createdAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   createdAt?: string | boolean,
+   /**
+    * Override the name of the deletedAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   deletedAt?: string | boolean,
+   /**
+    * Override the name of the updatedAt column if a string is provided, or disable it if false. Timestamps
+    * must be true. Not affected by underscored setting.
+    */
+   updatedAt?: string | boolean,
+   /**
+    * Defaults to pluralized model name, unless freezeTableName is true, in which case it uses model name
+    * verbatim
+    */
+   tableName?: string,
+   /**
+    * Provide getter functions that work like those defined per column. If you provide a getter method with
+    * the
+   same name as a column, it will be used to access the value of that column. If you provide a name that
+   does not match a column, this function will act as a virtual getter, that can fetch multiple other
+   values
+   */
+   getterMethods?: DefineGetterMethodsOptions,
+   /**
+    * Provide setter functions that work like those defined per column. If you provide a setter method with
+    * the
+   same name as a column, it will be used to update the value of that column. If you provide a name that
+   does not match a column, this function will act as a virtual setter, that can act on and set other
+   values, but will not be persisted
+   */
+   setterMethods?: DefineSetterMethodsOptions,
+   /**
+    * Provide functions that are added to each instance (DAO). If you override methods provided by sequelize,
+    * you can access the original method using `this.constructor.super_.prototype`, e.g.
+   `this.constructor.super_.prototype.toJSON.apply(this, arguments)`
+   */
+   instanceMethods?: Object,
+   /**
+    * Provide functions that are added to the model (Model). If you override methods provided by sequelize,
+    * you can access the original method using `this.constructor.prototype`, e.g.
+   `this.constructor.prototype.find.apply(this, arguments)`
+   */
+   classMethods?: Object,
+   schema: ?string,
+   schemaDelimeter: string,
+   /**
+    * You can also change the database engine, e.g. to MyISAM. InnoDB is the default.
+    */
+   engine?: string,
+   charset?: string,
+   /**
+    * Finaly you can specify a comment for the table in MySQL and PG
+    */
+   comment?: string,
+   collate?: string,
+   /**
+    * Set the initial AUTO_INCREMENT value for the table in MySQL.
+    */
+   initialAutoIncrement?: string,
+   /**
+    * An object of hook function that are called before and after certain lifecycle events.
+    * The possible hooks are: beforeValidate, afterValidate, beforeBulkCreate, beforeBulkDestroy,
+   beforeBulkUpdate, beforeCreate, beforeDestroy, beforeUpdate, afterCreate, afterDestroy, afterUpdate,
+   afterBulkCreate, afterBulkDestory and afterBulkUpdate. See Hooks for more information about hook
+   functions and their signatures. Each property can either be a function, or an array of functions.
+   */
+   hooks: HooksDefineOptions<TInstance>,
+   /**
+    * An object of model wide validations. Validations have access to all model values via `this`. If the
+    * validator function takes an argument, it is asumed to be async, and is called with a callback that
+   accepts an optional error.
+   */
+   validate: DefineValidateOptions,
+   /**
+    * Enable optimistic locking.  When enabled, sequelize will add a version count attribute
+    * to the model and throw an OptimisticLockingError error when stale instances are saved.
+   Set to true or a string with the attribute name you want to use to enable.
+   */
+   version?: boolean | string,
+   sequelize: Sequelize,
+   ...
+  }
+
+
+  /**
+   * Sync Options
+   * @see  Sequelize.sync
+   */
+  declare export type SyncOptions = {
+   /**
+    * If force is true, each DAO will do DROP TABLE IF EXISTS ..., before it tries to create its own table
+    */
+   force?: boolean,
+   /**
+    * Match a regex against the database name before syncing, a safety check for cases where force: true is
+    * used in tests but not live code
+    */
+   match?: RegExp,
+   /**
+    * A function that logs sql queries, or false for no logging
+    */
+   logging?: Function | boolean,
+   /**
+    * The schema that the tables should be created in. This can be overriden for each table in sequelize.define
+    */
+   schema?: string,
+   /**
+    * Alters tables to fit models. Not recommended for production use. Deletes data in columns
+    * that were removed or had their type changed in the model.
+    */
+   alter?: boolean,
+   /**
+    * If hooks is true then beforeSync, afterSync, beforBulkSync, afterBulkSync hooks will be called
+    */
+   hooks?: boolean,
+   /**
+    * An optional parameter to specify the schema search_path (Postgres only)
+    */
+   searchPath?: string,
+   ...
+  }
+
+  declare export type SetOptions = {...}
+
+
+  /**
+   * Connection Pool options
+   * @see  Options
+   */
+  declare export type PoolOptions = {
+   /**
+    * Maximum connections of the pool
+    */
+   max?: number,
+   /**
+    * Minimum connections of the pool
+    */
+   min?: number,
+   /**
+    * The maximum time, in milliseconds, that a connection can be idle before being released.
+    */
+   idle?: number,
+   /**
+    * The maximum time, in milliseconds, that pool will try to get connection before throwing error
+    */
+   acquire?: number,
+   /**
+    * A function that validates a connection. Called with client. The default function checks that client is an
+    * object, and that its state is not disconnected.
+    */
+   validate?: (client?: any) => boolean,
+   evict?: number,
+   ...
+  }
+
+
+  /**
+   * Interface for replication Options in the sequelize constructor
+   * @see  Options
+   */
+  declare export type ReplicationOptions = {
+   read?: {
+    host?: string,
+    port?: string | number,
+    username?: string,
+    password?: string,
+    database?: string,
+    ...
+   },
+   write?: {
+    host?: string,
+    port?: string | number,
+    username?: string,
+    password?: string,
+    database?: string,
+    ...
+   },
+   ...
+  }
+
+
+  /**
+   * Interface for retry Options in the sequelize constructor and QueryOptions
+   * @see  Options, QueryOptions
+   */
+  declare export type RetryOptions = {
+   /**
+    * Only retry a query if the error matches one of these strings or Regexes.
+    */
+   match?: Array<string | RegExp>,
+   /**
+    * How many times a failing query is automatically retried. Set to 0 to disable retrying on SQL_BUSY error.
+    */
+   max?: number,
+   ...
+  }
+
+
+  /**
+   * Operator symbols to be used when querying data
+   */
+  declare export type Operators = {
+   eq: Symbol,
+   ne: Symbol,
+   gte: Symbol,
+   gt: Symbol,
+   lte: Symbol,
+   lt: Symbol,
+   not: Symbol,
+   is: Symbol,
+   in: Symbol,
+   notIn: Symbol,
+   like: Symbol,
+   notLike: Symbol,
+   iLike: Symbol,
+   notILike: Symbol,
+   regexp: Symbol,
+   notRegexp: Symbol,
+   iRegexp: Symbol,
+   notIRegexp: Symbol,
+   between: Symbol,
+   notBetween: Symbol,
+   overlap: Symbol,
+   contains: Symbol,
+   contained: Symbol,
+   adjacent: Symbol,
+   strictLeft: Symbol,
+   strictRight: Symbol,
+   noExtendRight: Symbol,
+   noExtendLeft: Symbol,
+   and: Symbol,
+   or: Symbol,
+   any: Symbol,
+   all: Symbol,
+   values: Symbol,
+   col: Symbol,
+   placeholder: Symbol,
+   join: Symbol,
+   raw: Symbol,
+   Aliases: {
+    '$eq': Symbol,
+    '$ne': Symbol,
+    '$gte': Symbol,
+    '$gt': Symbol,
+    '$lte': Symbol,
+    '$lt': Symbol,
+    '$not': Symbol,
+    '$in': Symbol,
+    '$notIn': Symbol,
+    '$is': Symbol,
+    '$like': Symbol,
+    '$notLike': Symbol,
+    '$iLike': Symbol,
+    '$notILike': Symbol,
+    '$regexp': Symbol,
+    '$notRegexp': Symbol,
+    '$iRegexp': Symbol,
+    '$notIRegexp': Symbol,
+    '$between': Symbol,
+    '$notBetween': Symbol,
+    '$overlap': Symbol,
+    '$contains': Symbol,
+    '$contained': Symbol,
+    '$adjacent': Symbol,
+    '$strictLeft': Symbol,
+    '$strictRight': Symbol,
+    '$noExtendRight': Symbol,
+    '$noExtendLeft': Symbol,
+    '$and': Symbol,
+    '$or': Symbol,
+    '$any': Symbol,
+    '$all': Symbol,
+    '$values': Symbol,
+    '$col': Symbol,
+    '$raw': Symbol,
+    ...
+   },
+   LegacyAliases: {
+    ne: Symbol,
+    not: Symbol,
+    in: Symbol,
+    notIn: Symbol,
+    gte: Symbol,
+    gt: Symbol,
+    lte: Symbol,
+    lt: Symbol,
+    like: Symbol,
+    ilike: Symbol,
+    '$ilike': Symbol,
+    nlike: Symbol,
+    '$notlike': Symbol,
+    notilike: Symbol,
+    '..': Symbol,
+    between: Symbol,
+    '!..': Symbol,
+    notbetween: Symbol,
+    nbetween: Symbol,
+    overlap: Symbol,
+    '&&': Symbol,
+    '@>': Symbol,
+    '<@': Symbol,
+    '$eq': Symbol,
+    '$ne': Symbol,
+    '$gte': Symbol,
+    '$gt': Symbol,
+    '$lte': Symbol,
+    '$lt': Symbol,
+    '$not': Symbol,
+    '$in': Symbol,
+    '$notIn': Symbol,
+    '$is': Symbol,
+    '$like': Symbol,
+    '$notLike': Symbol,
+    '$iLike': Symbol,
+    '$notILike': Symbol,
+    '$regexp': Symbol,
+    '$notRegexp': Symbol,
+    '$iRegexp': Symbol,
+    '$notIRegexp': Symbol,
+    '$between': Symbol,
+    '$notBetween': Symbol,
+    '$overlap': Symbol,
+    '$contains': Symbol,
+    '$contained': Symbol,
+    '$adjacent': Symbol,
+    '$strictLeft': Symbol,
+    '$strictRight': Symbol,
+    '$noExtendRight': Symbol,
+    '$noExtendLeft': Symbol,
+    '$and': Symbol,
+    '$or': Symbol,
+    '$any': Symbol,
+    '$all': Symbol,
+    '$values': Symbol,
+    '$col': Symbol,
+    '$raw': Symbol,
+    ...
+   },
+   ...
+  }
+
+  declare export type OperatorsAliases = { [key: string]: Symbol, ... }
+
+
+  /**
+   * Options for the constructor of Sequelize main class
+   */
+  declare export type Options = {
+   /**
+    * The dialect of the database you are connecting to. One of mysql, postgres, sqlite, mariadb and mssql.
+    *
+   Defaults to 'mysql'
+   */
+   dialect?: string,
+   /**
+    * If specified, load the dialect library from this path. For example, if you want to use pg.js instead of
+    * pg when connecting to a pg database, you should specify 'pg.js' here
+    */
+   dialectModulePath?: string,
+   /**
+    * An object of additional options, which are passed directly to the connection library
+    */
+   dialectOptions?: Object,
+   /**
+    * Only used by sqlite.
+    *
+   Defaults to ':memory:'
+   */
+   storage?: string,
+   /**
+    * The host of the relational database.
+    *
+   Defaults to 'localhost'
+   */
+   host?: string,
+   /**
+    * The port of the relational database.
+    */
+   port?: number,
+   /**
+    * The protocol of the relational database.
+    *
+   Defaults to 'tcp'
+   */
+   protocol?: string,
+   /**
+    * The username which is used to authenticate against the database.
+    */
+   username?: string,
+   /**
+    * The password which is used to authenticate against the database.
+    */
+   password?: string,
+   /**
+    * The name of the database
+    */
+   database?: string,
+   /**
+    * Default options for model definitions. See sequelize.define for options
+    */
+   define?: DefineOptions<any>,
+   /**
+    * Default options for sequelize.query
+    */
+   query?: QueryOptions,
+   /**
+    * Default options for sequelize.set
+    */
+   set?: SetOptions,
+   /**
+    * Default options for sequelize.sync
+    */
+   sync?: SyncOptions,
+   /**
+    * The timezone used when converting a date from the database into a JavaScript date. The timezone is also
+    * used to SET TIMEZONE when connecting to the server, to ensure that the result of NOW, CURRENT_TIMESTAMP
+   and other time related functions have in the right timezone. For best cross platform performance use the
+   format
+   +/-HH:MM. Will also accept string versions of timezones used by moment.js (e.g. 'America/Los_Angeles');
+   this is useful to capture daylight savings time changes.
+
+   Defaults to '+00:00'
+   */
+   timezone?: string,
+   /**
+    * A function that gets executed everytime Sequelize would log something.
+    *
+   Defaults to console.log
+   */
+   logging?: boolean | Function,
+   /**
+    * A flag that defines if null values should be passed to SQL queries or not.
+    *
+   Defaults to false
+   */
+   omitNull?: boolean,
+   /**
+    * A flag that defines if native library shall be used or not. Currently only has an effect for postgres
+    *
+   Defaults to false
+   */
+   native?: boolean,
+   /**
+    * Use read / write replication. To enable replication, pass an object, with two properties, read and write.
+    * Write should be an object (a single server for handling writes), and read an array of object (several
+   servers to handle reads). Each read/write server can have the following properties: `host`, `port`,
+   `username`, `password`, `database`
+
+   Defaults to false
+   */
+   replication?: ReplicationOptions,
+   /**
+    * Set of flags that control when a query is automatically retried.
+    */
+   retry?: RetryOptions,
+   /**
+    * Run built in type validators on insert and update,
+    * e.g. validate that arguments passed to integer fields are integer-like.
+
+   Defaults to false
+   */
+   typeValidation?: boolean,
+   /**
+    * Connection pool options
+    */
+   pool?: PoolOptions,
+   /**
+    * Set to `false` to make table names and attributes case-insensitive on Postgres and skip double quoting of
+    * them.
+
+   Defaults to true
+   */
+   quoteIdentifiers?: boolean,
+   /**
+    * Set the default transaction isolation level. See `Sequelize.Transaction.ISOLATION_LEVELS` for possible
+    * options.
+
+   Defaults to 'REPEATABLE_READ'
+   */
+   isolationLevel?: TransactionIsolationLevel,
+   /**
+    * Set the default transaction type. See `Sequelize.Transaction.TYPES` for possible
+    * options.
+
+   Defaults to 'DEFERRED'
+   */
+   transactionType?: TransactionType,
+   /**
+    * Print query execution time in milliseconds when logging SQL.
+    *
+   Defaults to false
+   */
+   benchmark?: boolean,
+   /**
+    * String based operator alias, default value is true which will enable all operators alias.
+    * Pass object to limit set of aliased operators or false to disable completely.
+    */
+   operatorsAliases?: boolean | OperatorsAliases,
+   ...
+  }
+
+  declare export type QueryOptionsTransactionRequired = { transaction: Transaction, ... }
+
+  declare export type ModelsHashInterface = { [name: string]: Class<Model<any>>, ... }
+
+
+  /**
+   * This is the main class, the entry point to sequelize. To use it, you just need to
+   * import sequelize:
+
+  ```js
+  var Sequelize = require('sequelize');
+  ```
+
+  In addition to sequelize, the connection library for the dialect you want to use
+  should also be installed in your project. You don't need to import it however, as
+  sequelize will take care of that.
+  */
+  declare export default class Sequelize {
+    constructor(database: string, username?: ?string, password?: ?string, options?: Options): Sequelize;
+    constructor(database: string, options?: Options): Sequelize;
+    constructor(options: Options): Sequelize;
+
+    /**
+     * A modified version of bluebird promises, that allows listening for sql events
+     */
+    static Promise: typeof Promise,
+    Promise: typeof Promise,
+
+    /**
+     * Available query types for use with `sequelize.query`
+     */
+    static QueryTypes: QueryTypes,
+    QueryTypes: QueryTypes,
+
+    /**
+     * Exposes the validator.js object, so you can extend it with custom validation functions.
+     * The validator is exposed both on the instance, and on the constructor.
+     */
+    static Validator: Validator,
+    Validator: Validator,
+
+    /**
+     * A Model represents a table in the database. Sometimes you might also see it referred to as model, or
+     * simply as factory. This class should not be instantiated directly, it is created using sequelize.define,
+     and already created models can be loaded using sequelize.import
+     */
+    static Model: typeof Model,
+    Model: typeof Model,
+
+    /**
+     * A reference to the sequelize transaction class. Use this to access isolationLevels when creating a
+     * transaction
+     */
+    static Transaction: typeof Transaction,
+    Transaction: typeof Transaction,
+
+    /**
+     * A reference to the deferrable collection. Use this to access the different deferrable options.
+     */
+    static Deferrable: Deferrable,
+    Deferrable: Deferrable,
+
+    /**
+     * A reference to the sequelize instance class.
+     */
+    static Op: Operators,
+    Op: Operators,
+
+    /**
+     * Creates a object representing a database function. This can be used in search queries, both in where and
+     * order parts, and as default values in column definitions. If you want to refer to columns in your
+     function, you should use `sequelize.col`, so that the columns are properly interpreted as columns and
+     not a strings.
+
+     Convert a user's username to upper case
+     ```js
+     instance.updateAttributes({
+       username: self.sequelize.fn('upper', self.sequelize.col('username'))
+    })
+     ```
+     * @param fn The function you want to call
+     * @param args All further arguments will be passed as arguments to the function
+     */
+    static fn(fn: string, ...args: any[]): fn,
+    fn(fn: string, ...args: any[]): fn,
+
+    /**
+     * Creates a object representing a column in the DB. This is often useful in conjunction with
+     * `sequelize.fn`, since raw string arguments to fn will be escaped.
+     * @param col The name of the column
+     */
+    static col(col: string): col,
+    col(col: string): col,
+
+    /**
+     * Creates a object representing a call to the cast function.
+     * @param val The value to cast
+     * @param type The type to cast it to
+     */
+    static cast(val: any, type: string): cast,
+    cast(val: any, type: string): cast,
+
+    /**
+     * Creates a object representing a literal, i.e. something that will not be escaped.
+     * @param val
+     */
+    static literal(val: any): literal,
+    literal(val: any): literal,
+    static asIs(val: any): literal,
+    asIs(val: any): literal,
+
+    /**
+     * An AND query
+     * @param args Each argument will be joined by AND
+     */
+    static and(...args: $ReadOnlyArray<string | Object>): AndOperator,
+    and(...args: $ReadOnlyArray<string | Object>): AndOperator,
+
+    /**
+     * An OR query
+     * @param args Each argument will be joined by OR
+     */
+    static or(...args: $ReadOnlyArray<string | Object>): OrOperator,
+    or(...args: $ReadOnlyArray<string | Object>): OrOperator,
+
+    /**
+     * Creates an object representing nested where conditions for postgres's json data-type.
+     * @param conditionsOrPath A hash containing strings/numbers or other nested hash, a string using dot
+     notation or a string using postgres json syntax.
+     * @param value An optional value to compare against. Produces a string of the form "<json path> =
+     '<value>'".
+     */
+    static json(
+      conditionsOrPath: string | Object,
+      value?: string | number | boolean): json,
+    json(
+      conditionsOrPath: string | Object,
+      value?: string | number | boolean): json,
+
+    /**
+     * A way of specifying attr = condition.
+     *
+     The attr can either be an object taken from `Model.rawAttributes` (for example `Model.rawAttributes.id`
+     or
+     `Model.rawAttributes.name`). The attribute should be defined in your model definition. The attribute can
+     also be an object from one of the sequelize utility functions (`sequelize.fn`, `sequelize.col` etc.)
+
+     For string attributes, use the regular `{ where: { attr: something }}` syntax. If you don't want your
+     string to be escaped, use `sequelize.literal`.
+     * @param attr The attribute, which can be either an attribute object from `Model.rawAttributes` or a
+     sequelize object, for example an instance of `sequelize.fn`. For simple string attributes, use the
+     POJO syntax
+     * @param comparator Comparator
+     * @param logic The condition. Can be both a simply type, or a further condition (`.or`, `.and`, `.literal`
+     etc.)
+     */
+    static where(attr: Object, comparator: string, logic: string | Object): where,
+    where(attr: Object, comparator: string, logic: string | Object): where,
+    static where(attr: Object, logic: string | Object): where,
+    where(attr: Object, logic: string | Object): where,
+    static condition(attr: Object, comparator: string, logic: string | Object): where,
+    condition(attr: Object, comparator: string, logic: string | Object): where,
+    static condition(attr: Object, logic: string | Object): where,
+    condition(attr: Object, logic: string | Object): where,
+
+    static Error: typeof BaseError,
+    static ValidationError: typeof ValidationError,
+    static ValidationErrorItem: typeof ValidationErrorItem,
+    static DatabaseError: typeof DatabaseError,
+    static TimeoutError: typeof TimeoutError,
+    static UniqueConstraintError: typeof UniqueConstraintError,
+    static ExclusionConstraintError: typeof ExclusionConstraintError,
+    static ForeignKeyConstraintError: typeof ForeignKeyConstraintError,
+    static ConnectionError: typeof ConnectionError,
+    static ConnectionRefusedError: typeof ConnectionRefusedError,
+    static AccessDeniedError: typeof AccessDeniedError,
+    static HostNotFoundError: typeof HostNotFoundError,
+    static HostNotReachableError: typeof HostNotReachableError,
+    static InvalidConnectionError: typeof InvalidConnectionError,
+    static ConnectionTimedOutError: typeof ConnectionTimedOutError,
+    static EmptyResultError: typeof EmptyResultError,
+
+    Error: typeof BaseError,
+    ValidationError: typeof ValidationError,
+    ValidationErrorItem: typeof ValidationErrorItem,
+    DatabaseError: typeof DatabaseError,
+    TimeoutError: typeof TimeoutError,
+    UniqueConstraintError: typeof UniqueConstraintError,
+    ExclusionConstraintError: typeof ExclusionConstraintError,
+    ForeignKeyConstraintError: typeof ForeignKeyConstraintError,
+    ConnectionError: typeof ConnectionError,
+    ConnectionRefusedError: typeof ConnectionRefusedError,
+    AccessDeniedError: typeof AccessDeniedError,
+    HostNotFoundError: typeof HostNotFoundError,
+    HostNotReachableError: typeof HostNotReachableError,
+    InvalidConnectionError: typeof InvalidConnectionError,
+    ConnectionTimedOutError: typeof ConnectionTimedOutError,
+    EmptyResultError: typeof EmptyResultError,
+
+    static ABSTRACT: DataTypeAbstract,
+    static STRING: DataTypeString,
+    static CHAR: DataTypeChar,
+    static TEXT: DataTypeText,
+    static NUMBER: DataTypeNumber,
+    static INTEGER: DataTypeInteger,
+    static BIGINT: DataTypeBigInt,
+    static FLOAT: DataTypeFloat,
+    static TIME: DataTypeTime,
+    static DATE: DataTypeDate,
+    static DATEONLY: DataTypeDateOnly,
+    static BOOLEAN: DataTypeBoolean,
+    static NOW: DataTypeNow,
+    static BLOB: DataTypeBlob,
+    static DECIMAL: DataTypeDecimal,
+    static NUMERIC: DataTypeDecimal,
+    static UUID: DataTypeUUID,
+    static UUIDV1: DataTypeUUIDv1,
+    static UUIDV4: DataTypeUUIDv4,
+    static HSTORE: DataTypeHStore,
+    static JSON: DataTypeJSONType,
+    static JSONB: DataTypeJSONB,
+    static VIRTUAL: DataTypeVirtual,
+    static ARRAY: DataTypeArray,
+    static NONE: DataTypeVirtual,
+    static ENUM: DataTypeEnum,
+    static RANGE: DataTypeRange,
+    static REAL: DataTypeReal,
+    static DOUBLE: DataTypeDouble,
+    static GEOMETRY: DataTypeGeometry,
+
+    /**
+     * Add a hook to the model
+     * @param hookType
+     * @param name Provide a name for the hook function. It can be used to remove the hook later or to order
+     hooks based on some sort of priority system in the future.
+     * @param fn The hook function
+     * @alias  hook
+     */
+    static addHook(hookType: string, name: string, fn: Function): this,
+    static addHook(hookType: string, fn: Function): this,
+    static hook(hookType: string, name: string, fn: Function): this,
+    static hook(hookType: string, fn: Function): this,
+
+    /**
+     * Remove hook from the model
+     * @param hookType
+     * @param name
+     */
+    static removeHook(hookType: string, name: string): this,
+
+    /**
+     * Check whether the model has any hooks of this type
+     * @param hookType
+     * @alias  hasHooks
+     */
+    static hasHook(hookType: string): boolean,
+    static hasHooks(hookType: string): boolean,
+
+    /**
+     * A hook that is run before validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static beforeValidate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeValidate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static afterValidate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static afterValidate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static validationFailed(
+      name: string,
+      fn: AsyncFn3<Model<any>, Object, ValidationError>): void,
+    static validationFailed(fn: AsyncFn3<Model<any>, Object, ValidationError>): void,
+
+    /**
+     * A hook that is run before creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static beforeCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeCreate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static afterCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static afterCreate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  beforeDelete
+     */
+    static beforeDestroy(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeDestroy(fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeDelete(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeDelete(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  afterDelete
+     */
+    static afterDestroy(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static afterDestroy(fn: AsyncFn2<Model<any>, Object>): void,
+    static afterDelete(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static afterDelete(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static beforeUpdate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static beforeUpdate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    static afterUpdate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    static afterUpdate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     */
+    static beforeBulkCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>[], Object>): void,
+    static beforeBulkCreate(fn: AsyncFn2<Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run after creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     * @name  afterBulkCreate
+     */
+    static afterBulkCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>[], Object>): void,
+    static afterBulkCreate(fn: AsyncFn2<Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run before destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  beforeBulkDelete
+     */
+    static beforeBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkDestroy(fn: AsyncFn1<Object>): void,
+    static beforeBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  afterBulkDelete
+     */
+    static afterBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkDestroy(fn: AsyncFn1<Object>): void,
+    static afterBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    static beforeBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static afterBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    static afterBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFind(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFind(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFindAfterExpandIncludeAll(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFindAfterExpandIncludeAll(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after all option parsing is complete
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    static beforeFindAfterOptions(name: string, fn: AsyncFn1<Object>): void,
+    static beforeFindAfterOptions(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after a find (select) query
+     * @param name
+     * @param fn A callback function that is called with instance(s), options
+     */
+    static afterFind(
+      name: string,
+      AsyncFn2<Model<any> | Model<any>[], Object>): void,
+    static afterFind(
+      AsyncFn2<Model<any> | Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run before a define call
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    static beforeDefine(
+      name: string,
+      fn: AsyncFn2<DefineAttributes, Object>): void,
+    static beforeDefine(fn: AsyncFn2<DefineAttributes, Object>): void,
+
+    /**
+     * A hook that is run after a define call
+     * @param name
+     * @param fn A callback function that is called with factory
+     */
+    static afterDefine(name: string, fn: AsyncFn1<Model<Model<any>, any>>): void,
+    static afterDefine(fn: AsyncFn1<Model<Model<any>, any>>): void,
+
+    /**
+     * A hook that is run before Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with config, options
+     */
+    static beforeInit(name: string, fn: AsyncFn2<Object, Object>): void,
+    static beforeInit(fn: AsyncFn2<Object, Object>): void,
+
+    /**
+     * A hook that is run after Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with sequelize
+     */
+    static afterInit(name: string, fn: AsyncFn1<Sequelize>): void,
+    static afterInit(fn: AsyncFn1<Sequelize>): void,
+
+    /**
+     * A hook that is run before Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    static beforeSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static beforeSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    static afterSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static afterSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run before sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    static beforeBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static beforeBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    static afterBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    static afterBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * Add a hook to the model
+     * @param hookType
+     * @param name Provide a name for the hook function. It can be used to remove the hook later or to order
+     hooks based on some sort of priority system in the future.
+     * @param fn The hook function
+     * @alias  hook
+     */
+    addHook(hookType: string, name: string, fn: Function): this,
+    addHook(hookType: string, fn: Function): this,
+    hook(hookType: string, name: string, fn: Function): this,
+    hook(hookType: string, fn: Function): this,
+
+    /**
+     * Remove hook from the model
+     * @param hookType
+     * @param name
+     */
+    removeHook(hookType: string, name: string): this,
+
+    /**
+     * Check whether the model has any hooks of this type
+     * @param hookType
+     * @alias  hasHooks
+     */
+    hasHook(hookType: string): boolean,
+    hasHooks(hookType: string): boolean,
+
+    /**
+     * A hook that is run before validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    beforeValidate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    beforeValidate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    afterValidate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    afterValidate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after validation
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    validationFailed(
+      name: string,
+      fn: AsyncFn3<Model<any>, Object, ValidationError>): void,
+    validationFailed(fn: AsyncFn3<Model<any>, Object, ValidationError>): void,
+
+    /**
+     * A hook that is run before creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    beforeCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    beforeCreate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after creating a single instance
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    afterCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    afterCreate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  beforeDelete
+     */
+    beforeDestroy(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    beforeDestroy(fn: AsyncFn2<Model<any>, Object>): void,
+    beforeDelete(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    beforeDelete(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after destroying a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     * @alias  afterDelete
+     */
+    afterDestroy(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    afterDestroy(fn: AsyncFn2<Model<any>, Object>): void,
+    afterDelete(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    afterDelete(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    beforeUpdate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    beforeUpdate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run after updating a single instance
+     * @param name
+     * @param fn A callback function that is called with instance, options
+     */
+    afterUpdate(
+      name: string,
+      fn: AsyncFn2<Model<any>, Object>): void,
+    afterUpdate(fn: AsyncFn2<Model<any>, Object>): void,
+
+    /**
+     * A hook that is run before creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     */
+    beforeBulkCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>[], Object>): void,
+    beforeBulkCreate(fn: AsyncFn2<Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run after creating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with instances, options
+     * @name  afterBulkCreate
+     */
+    afterBulkCreate(
+      name: string,
+      fn: AsyncFn2<Model<any>[], Object>): void,
+    afterBulkCreate(fn: AsyncFn2<Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run before destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  beforeBulkDelete
+     */
+    beforeBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    beforeBulkDestroy(fn: AsyncFn1<Object>): void,
+    beforeBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    beforeBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after destroying instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     * @alias  afterBulkDelete
+     */
+    afterBulkDestroy(name: string, fn: AsyncFn1<Object>): void,
+    afterBulkDestroy(fn: AsyncFn1<Object>): void,
+    afterBulkDelete(name: string, fn: AsyncFn1<Object>): void,
+    afterBulkDelete(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    beforeBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    beforeBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after updating instances in bulk
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    afterBulkUpdate(name: string, fn: AsyncFn1<Object>): void,
+    afterBulkUpdate(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    beforeFind(name: string, fn: AsyncFn1<Object>): void,
+    beforeFind(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    beforeFindAfterExpandIncludeAll(name: string, fn: AsyncFn1<Object>): void,
+    beforeFindAfterExpandIncludeAll(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run before a find (select) query, after all option parsing is complete
+     * @param name
+     * @param fn A callback function that is called with options
+     */
+    beforeFindAfterOptions(name: string, fn: AsyncFn1<Object>): void,
+    beforeFindAfterOptions(fn: AsyncFn1<Object>): void,
+
+    /**
+     * A hook that is run after a find (select) query
+     * @param name
+     * @param fn A callback function that is called with instance(s), options
+     */
+    afterFind(
+      name: string,
+      AsyncFn2<Model<any> | Model<any>[], Object>): void,
+    afterFind(
+      AsyncFn2<Model<any> | Model<any>[], Object>): void,
+
+    /**
+     * A hook that is run before a define call
+     * @param name
+     * @param fn A callback function that is called with attributes, options
+     */
+    beforeDefine(
+      name: string,
+      fn: AsyncFn2<DefineAttributes, Object>): void,
+    beforeDefine(fn: AsyncFn2<DefineAttributes, Object>): void,
+
+    /**
+     * A hook that is run after a define call
+     * @param name
+     * @param fn A callback function that is called with factory
+     */
+    afterDefine(name: string, fn: AsyncFn1<Model<Model<any>, any>>): void,
+    afterDefine(fn: AsyncFn1<Model<Model<any>, any>>): void,
+
+    /**
+     * A hook that is run before Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with config, options
+     */
+    beforeInit(name: string, fn: AsyncFn2<Object, Object>): void,
+    beforeInit(fn: AsyncFn2<Object, Object>): void,
+
+    /**
+     * A hook that is run after Sequelize() call
+     * @param name
+     * @param fn A callback function that is called with sequelize
+     */
+    afterInit(name: string, fn: AsyncFn1<Sequelize>): void,
+    afterInit(fn: AsyncFn1<Sequelize>): void,
+
+    /**
+     * A hook that is run before Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    beforeSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    beforeSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after Model.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to Model.sync
+     */
+    afterSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    afterSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run before sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    beforeBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    beforeBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+    /**
+     * A hook that is run after sequelize.sync call
+     * @param name
+     * @param fn A callback function that is called with options passed to sequelize.sync
+     */
+    afterBulkSync(name: string, fn: AsyncFn1<SyncOptions>): void,
+    afterBulkSync(fn: AsyncFn1<SyncOptions>): void,
+
+  /**
+     * Defined models.
+     */
+    models: ModelsHashInterface,
+
+    /**
+     * Defined options.
+     */
+    options: Options,
+
+    /**
+     * Returns the specified dialect.
+     */
+    getDialect(): string,
+
+    /**
+     * Returns an instance of QueryInterface.
+     */
+    getQueryInterface(): QueryInterface,
+
+    /**
+     * Define a new model, representing a table in the DB.
+     *
+    The table columns are define by the hash that is given as the second argument. Each attribute of the
+    hash
+    represents a column. A short table definition might look like this:
+
+    ```js
+    sequelize.define('modelName', {
+       columnA: {
+         type: Sequelize.BOOLEAN,
+         validate: {
+           is: ["[a-z]",'i'],    // will only allow letters
+           max: 23,          // only allow values <= 23
+           isIn: {
+           args: [['en', 'zh']],
+           msg: "Must be English or Chinese"
+           }
+         },
+         field: 'column_a'
+         // Other attributes here
+       },
+       columnB: Sequelize.STRING,
+       columnC: 'MY VERY OWN COLUMN TYPE'
+    })
+
+    sequelize.models.modelName // The model will now be available in models under the name given to define
+    ```
+
+    As shown above, column definitions can be either strings, a reference to one of the datatypes that are
+    predefined on the Sequelize constructor, or an object that allows you to specify both the type of the
+    column, and other attributes such as default values, foreign key constraints and custom setters and
+    getters.
+
+    For a list of possible data types, see
+    http://docs.sequelizejs.com/en/latest/docs/models-definition/#data-types
+
+    For more about getters and setters, see
+    http://docs.sequelizejs.com/en/latest/docs/models-definition/#getters-setters
+
+    For more about instance and class methods, see
+    http://docs.sequelizejs.com/en/latest/docs/models-definition/#expansion-of-models
+
+    For more about validation, see
+    http://docs.sequelizejs.com/en/latest/docs/models-definition/#validations
+     * @param modelName The name of the model. The model will be stored in `sequelize.models` under this name
+     * @param attributes An object, where each attribute is a column of the table. Each column can be either a
+    DataType, a string or a type-description object, with the properties described below:
+     * @param options These options are merged with the default define options provided to the Sequelize
+    constructor
+    */
+    define<TAttributes, TPlainAttributes, TInstance: Model<TAttributes, TPlainAttributes>>(
+      modelName: string,
+      attributes: DefineAttributes,
+      options?: DefineOptions<TInstance>): Class<TInstance>,
+
+    /**
+     * Fetch a Model which is already defined
+     * @param modelName The name of a model defined with Sequelize.define
+     */
+    model<ModelClass: Class<Model<any>>>(modelName: string): ModelClass,
+
+    /**
+     * Checks whether a model with the given name is defined
+     * @param modelName The name of a model defined with Sequelize.define
+     */
+    isDefined(modelName: string): boolean,
+
+    /**
+     * Imports a model defined in another file
+     *
+    Imported models are cached, so multiple calls to import with the same path will not load the file
+    multiple times
+
+    See https://github.com/sequelize/sequelize/blob/master/examples/using-multiple-model-files/Task.js for a
+    short example of how to define your models in separate files so that they can be imported by
+    sequelize.import
+     * @param path The path to the file that holds the model you want to import. If the part is relative, it
+    will be resolved relatively to the calling file
+     * @param defineFunction An optional function that provides model definitions. Useful if you do not
+    want to use the module root as the define function
+    */
+    import<ModelClass: Class<Model<any>>>(
+      path: string,
+      defineFunction?: (
+        sequelize: Sequelize,
+        dataTypes: DataTypes) => ModelClass): ModelClass,
+
+    /**
+     * Execute a query on the DB, with the posibility to bypass all the sequelize goodness.
+     *
+    By default, the function will return two arguments: an array of results, and a metadata object,
+    containing number of affected rows etc. Use `.spread` to access the results.
+
+    If you are running a type of query where you don't need the metadata, for example a `SELECT` query, you
+    can pass in a query type to make sequelize format the results:
+
+    ```js
+    sequelize.query('SELECT...').spread(function (results, metadata) {
+       // Raw query - use spread
+    });
+
+    sequelize.query('SELECT...', { type: sequelize.QueryTypes.SELECT }).then(function (results) {
+       // SELECT query - use then
+    })
+    ```
+     * @param sql
+     * @param options Query options
+    */
+    query(
+      sql: string | {
+       query: string,
+       values: any[],
+       ...
+      },
+      options?: QueryOptions): Promise<any>,
+
+    /**
+     * Execute a query which would set an environment or user variable. The variables are set per connection,
+     * so this function needs a transaction.
+
+    Only works for MySQL.
+     * @param variables Object with multiple variables.
+     * @param options Query options.
+    */
+    set(
+      variables: Object,
+      options: QueryOptionsTransactionRequired): Promise<any>,
+
+    /**
+     * Escape value.
+     * @param value Value that needs to be escaped
+     */
+    escape(value: string): string,
+
+    /**
+     * Create a new database schema.
+     *
+    Note,that this is a schema in the
+    [postgres sense of the word](http://www.postgresql.org/docs/9.1/static/ddl-schemas.html),
+    not a database table. In mysql and sqlite, this command will do nothing.
+     * @param schema Name of the schema
+     * @param options Options supplied
+     * @param options .logging A function that logs sql queries, or false for no logging
+    */
+    createSchema(schema: string, options: { logging?: boolean | Function, ... }): Promise<any>,
+
+    /**
+     * Show all defined schemas
+     *
+    Note,that this is a schema in the
+    [postgres sense of the word](http://www.postgresql.org/docs/9.1/static/ddl-schemas.html),
+    not a database table. In mysql and sqlite, this will show all tables.
+     * @param options Options supplied
+     * @param options .logging A function that logs sql queries, or false for no logging
+    */
+    showAllSchemas(options: { logging?: boolean | Function, ... }): Promise<any>,
+
+    /**
+     * Drop a single schema
+     *
+    Note,that this is a schema in the
+    [postgres sense of the word](http://www.postgresql.org/docs/9.1/static/ddl-schemas.html),
+    not a database table. In mysql and sqlite, this drop a table matching the schema name
+     * @param schema Name of the schema
+     * @param options Options supplied
+     * @param options .logging A function that logs sql queries, or false for no logging
+    */
+    dropSchema(schema: string, options: { logging?: boolean | Function, ... }): Promise<any>,
+
+    /**
+     * Drop all schemas
+     *
+    Note,that this is a schema in the
+    [postgres sense of the word](http://www.postgresql.org/docs/9.1/static/ddl-schemas.html),
+    not a database table. In mysql and sqlite, this is the equivalent of drop all tables.
+     * @param options Options supplied
+     * @param options .logging A function that logs sql queries, or false for no logging
+    */
+    dropAllSchemas(options: { logging?: boolean | Function, ... }): Promise<any>,
+
+    /**
+     * Sync all defined models to the DB.
+     * @param options Sync Options
+     */
+    sync(options?: SyncOptions): Promise<any>,
+
+    /**
+     * Truncate all tables defined through the sequelize models. This is done
+     * by calling Model.truncate() on each model.
+     * @param  The options passed to Model.destroy in addition to truncate
+     * @param  .transaction]
+     * @param  .logging] A function that logs sql queries, or false for no logging
+     */
+    truncate(options?: DestroyOptions): Promise<any>,
+
+    /**
+     * Drop all tables defined through this sequelize instance. This is done by calling Model.drop on each model
+     * @see  {Model#drop} for options
+     * @param options The options passed to each call to Model.drop
+     */
+    drop(options?: DropOptions): Promise<any>,
+
+    /**
+     * Test the connection by trying to authenticate
+     * @param options Query Options for authentication
+     */
+    authenticate(options?: QueryOptions): Promise<void>,
+    validate(options?: QueryOptions): Promise<ValidationError>,
+
+    /**
+     * Start a transaction. When using transactions, you should pass the transaction in the options argument
+     * in order for the query to happen under that transaction
+
+    ```js
+    sequelize.transaction().then(function (t) {
+       return User.find(..., { transaction: t}).then(function (user) {
+       return user.updateAttributes(..., { transaction: t});
+       })
+       .then(t.commit.bind(t))
+       .catch(t.rollback.bind(t));
+    })
+    ```
+
+    A syntax for automatically committing or rolling back based on the promise chain resolution is also
+    supported:
+
+    ```js
+    sequelize.transaction(function (t) { // Note that we use a callback rather than a promise.then()
+       return User.find(..., { transaction: t}).then(function (user) {
+       return user.updateAttributes(..., { transaction: t});
+       });
+    }).then(function () {
+       // Commited
+    }).catch(function (err) {
+       // Rolled back
+       console.error(err);
+    });
+    ```
+
+    If you have [CLS](https://github.com/othiym23/node-continuation-local-storage) enabled, the transaction
+    will automatically be passed to any query that runs witin the callback. To enable CLS, add it do your
+    project, create a namespace and set it on the sequelize constructor:
+
+    ```js
+    var cls = require('continuation-local-storage'),
+       ns = cls.createNamespace('....');
+    var Sequelize = require('sequelize');
+    Sequelize.cls = ns;
+    ```
+    Note, that CLS is enabled for all sequelize instances, and all instances will share the same namespace
+     * @param options Transaction Options
+     * @param autoCallback Callback for the transaction
+    */
+    transaction<T, Fn: TransactionAutoCallback<T>>(autoCallback: Fn): Promise<T>,
+    transaction<T, Fn: TransactionAutoCallback<T>>(
+      options: TransactionOptions,
+      autoCallback: Fn): Promise<T>,
+    transaction(options?: TransactionOptions): Promise<Transaction>,
+
+    /**
+     * Close all connections used by this sequelize instance, and free all references so the instance can be
+     * garbage collected.
+
+    Normally this is done on process exit, so you only need to call this method if you are creating multiple
+    instances, and want to garbage collect some of them.
+    */
+    close(): Promise<void>,
+
+    /**
+     * Returns the database version
+     */
+    databaseVersion(): Promise<string>,
+  }
+
+
+
+  /**
+   * Validator Interface
+   */
+  declare export type Validator = {
+   notEmpty(str: string): boolean,
+   len(str: string, min: number, max: number): boolean,
+   isUrl(str: string): boolean,
+   isIPv6(str: string): boolean,
+   isIPv4(str: string): boolean,
+   notIn(str: string, values: string[]): boolean,
+   regex(str: string, pattern: string, modifiers: string): boolean,
+   notRegex(str: string, pattern: string, modifiers: string): boolean,
+   isDecimal(str: string): boolean,
+   min(str: string, val: number): boolean,
+   max(str: string, val: number): boolean,
+   not(str: string, pattern: string, modifiers: string): boolean,
+   contains(str: string, element: string[]): boolean,
+   notContains(str: string, element: string[]): boolean,
+   is(str: string, pattern: string, modifiers: string): boolean,
+   ...
+  }
+
+
+  /**
+   * The transaction object is used to identify a running transaction. It is created by calling
+   * `Sequelize.transaction()`.
+
+  To run a query under a transaction, you should pass the transaction in the options object.
+  */
+  declare export class Transaction {
+    /**
+     * Commit the transaction
+     */
+    commit(): Promise<void>,
+
+    /**
+     * Rollback (abort) the transaction
+     */
+    rollback(): Promise<void>,
+
+    /**
+     * A hook that is run after a transaction is committed
+     */
+    afterCommit(hook: (transaction: Transaction) => Promise<void>): void,
+
+    /**
+     * Isolations levels can be set per-transaction by passing `options.isolationLevel` to
+     * `sequelize.transaction`. Default to `REPEATABLE_READ` but you can override the default isolation level
+     by passing
+     `options.isolationLevel` in `new Sequelize`.
+
+     The possible isolations levels to use when starting a transaction:
+
+     ```js
+     {
+        READ_UNCOMMITTED: "READ_UNCOMMITTED",
+        READ_COMMITTED: "READ_COMMITTED",
+        REPEATABLE_READ: "REPEATABLE_READ",
+        SERIALIZABLE: "SERIALIZABLE"
+     }
+     ```
+
+     Pass in the desired level as the first argument:
+
+     ```js
+     return sequelize.transaction({
+       isolationLevel: Sequelize.Transaction.SERIALIZABLE
+    }, function (t) {
+
+      // your transactions
+
+    }).then(function(result) {
+       // transaction has been committed. Do something after the commit if required.
+    }).catch(function(err) {
+       // do something with the err.
+    });
+     ```
+     * @see  ISOLATION_LEVELS
+     */
+    static ISOLATION_LEVELS: TransactionIsolationLevels,
+    ISOLATION_LEVELS: TransactionIsolationLevels,
+
+    /**
+     * Transaction type can be set per-transaction by passing `options.type` to
+     * `sequelize.transaction`. Default to `DEFERRED` but you can override the default isolation level
+     by passing `options.transactionType` in `new Sequelize`.
+
+     The transaction types to use when starting a transaction:
+
+     ```js
+     {
+        DEFERRED: "DEFERRED",
+        IMMEDIATE: "IMMEDIATE",
+        EXCLUSIVE: "EXCLUSIVE"
+     }
+     ```
+
+     Pass in the transaction type the first argument:
+
+     ```js
+     return sequelize.transaction({
+       type: Sequelize.Transaction.EXCLUSIVE
+    }, function (t) {
+
+      // your transactions
+
+    }).then(function(result) {
+       // transaction has been committed. Do something after the commit if required.
+    }).catch(function(err) {
+       // do something with the err.
+    });
+     ```
+     * @see  Sequelize.Transaction.TYPES
+     */
+    static TYPES: TransactionTypes,
+    TYPES: TransactionTypes,
+
+    /**
+     * Possible options for row locking. Used in conjuction with `find` calls:
+     *
+     ```js
+     t1 // is a transaction
+     t1.LOCK.UPDATE,
+     t1.LOCK.SHARE,
+     t1.LOCK.KEY_SHARE, // Postgres 9.3+ only
+     t1.LOCK.NO_KEY_UPDATE // Postgres 9.3+ only
+     ```
+
+     Usage:
+     ```js
+     t1 // is a transaction
+     Model.findAll({
+       where: ...,
+       transaction: t1,
+       lock: t1.LOCK...
+    });
+     ```
+
+     Postgres also supports specific locks while eager loading by using OF:
+     ```js
+     UserModel.findAll({
+       where: ...,
+       include: [TaskModel, ...],
+       transaction: t1,
+       lock: {
+       level: t1.LOCK...,
+       of: UserModel
+       }
+    });
+     ```
+     UserModel will be locked but TaskModel won't!
+     */
+    static LOCK: TransactionLock,
+    LOCK: TransactionLock,
+  }
+
+  declare export type TransactionIsolationLevelReadUncommitted = 'READ_UNCOMMITTED';
+
+  declare export type TransactionIsolationLevelReadCommitted = 'READ_COMMITTED';
+
+  declare export type TransactionIsolationLevelRepeatableRead = 'REPEATABLE_READ';
+
+  declare export type TransactionIsolationLevelSerializable = 'SERIALIZABLE';
+
+  declare export type TransactionIsolationLevel = TransactionIsolationLevelReadUncommitted | TransactionIsolationLevelReadCommitted | TransactionIsolationLevelRepeatableRead | TransactionIsolationLevelSerializable;
+
+
+  /**
+   * Isolations levels can be set per-transaction by passing `options.isolationLevel` to `sequelize.transaction`.
+   * Default to `REPEATABLE_READ` but you can override the default isolation level by passing
+  `options.isolationLevel` in `new Sequelize`.
+  */
+  declare export type TransactionIsolationLevels = {
+   READ_UNCOMMITTED: TransactionIsolationLevelReadUncommitted,
+   READ_COMMITTED: TransactionIsolationLevelReadCommitted,
+   REPEATABLE_READ: TransactionIsolationLevelRepeatableRead,
+   SERIALIZABLE: TransactionIsolationLevelSerializable,
+   ...
+  }
+
+  declare export type TransactionTypeDeferred = 'DEFERRED';
+
+  declare export type TransactionTypeImmediate = 'IMMEDIATE';
+
+  declare export type TransactionTypeExclusive = 'EXCLUSIVE';
+
+  declare export type TransactionType = TransactionTypeDeferred | TransactionTypeImmediate | TransactionTypeExclusive;
+
+
+  /**
+   * Transaction type can be set per-transaction by passing `options.type` to `sequelize.transaction`.
+   * Default to `DEFERRED` but you can override the default isolation level by passing
+  `options.transactionType` in `new Sequelize`.
+  */
+  declare export type TransactionTypes = {
+   DEFERRED: TransactionTypeDeferred,
+   IMMEDIATE: TransactionTypeImmediate,
+   EXCLUSIVE: TransactionTypeExclusive,
+   ...
+  }
+
+  declare export type TransactionLockLevelUpdate = 'UPDATE';
+
+  declare export type TransactionLockLevelShare = 'SHARE';
+
+  declare export type TransactionLockLevelKeyShare = 'KEY_SHARE';
+
+  declare export type TransactionLockLevelNoKeyUpdate = 'NO_KEY_UPDATE';
+
+  declare export type TransactionLockLevel =
+    TransactionLockLevelUpdate |
+    TransactionLockLevelShare |
+    TransactionLockLevelKeyShare |
+    TransactionLockLevelNoKeyUpdate;
+
+  /**
+   * Possible options for row locking. Used in conjuction with `find` calls:
+   */
+  declare export type TransactionLock = {
+   UPDATE: TransactionLockLevelUpdate,
+   SHARE: TransactionLockLevelShare,
+   KEY_SHARE: TransactionLockLevelKeyShare,
+   NO_KEY_UPDATE: TransactionLockLevelNoKeyUpdate,
+   ...
+  }
+
+
+  /**
+   * Options provided when the transaction is created
+   * @see  sequelize.transaction()
+   */
+  declare export type TransactionOptions = {
+   autocommit?: boolean,
+   /**
+    * See `Sequelize.Transaction.ISOLATION_LEVELS` for possible options
+    */
+   isolationLevel?: TransactionIsolationLevel,
+   /**
+    * See `Sequelize.Transaction.TYPES` for possible options
+    */
+   type?: TransactionType,
+   /**
+    * A function that gets executed while running the query to log the sql.
+    */
+   logging?: Function,
+   ...
+  }
+
+  declare type TransactionAutoCallback<T> = (t:Transaction) => Promise<T> | T
+
+  declare export interface fn {
+    fn: string,
+    args: any[]
+  }
+
+  declare export interface col {
+    col: string
+  }
+
+  declare export interface cast {
+    val: any,
+    type: string
+  }
+
+  declare export interface literal {
+    val: any
+  }
+
+  declare export interface json {
+    conditions?: Object,
+    path?: string,
+    value?: string | number | boolean
+  }
+
+  declare export interface where {
+    attribute: Object,
+    comparator?: string,
+    logic: string | Object
+  }
+}
diff --git a/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/test_sequelize.js b/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/test_sequelize.js
new file mode 100644
index 0000000000..dec4eaf18c
--- /dev/null
+++ b/definitions/npm/sequelize_v4.x.x/flow_v0.201.x-/test_sequelize.js
@@ -0,0 +1,1948 @@
+// @flow
+
+import Sequelize, {Model, Transaction} from "sequelize";
+import type {fn} from 'sequelize'
+import type { DefineAttributes } from "sequelize";
+import type {
+  HasOneGetOne,
+  HasOneSetOne,
+  HasOneCreateOne,
+  HasManyCreateOne,
+  HasManyRemoveOne,
+  BelongsToGetOne,
+  BelongsToSetOne,
+  BelongsToCreateOne,
+  BelongsToManyCreateOne,
+  HasManyGetMany,
+  HasManySetMany,
+  HasManyAddMany,
+  HasManyAddOne,
+  HasManyRemoveMany,
+  HasManyHasOne,
+  HasManyHasMany,
+  HasManyCount,
+  BelongsToManyGetMany,
+  BelongsToManySetMany,
+  BelongsToManyAddMany,
+  BelongsToManyAddOne,
+  BelongsToManyRemoveOne,
+  BelongsToManyRemoveMany,
+  BelongsToManyHasOne,
+  BelongsToManyHasMany,
+  BelongsToManyCount,
+  Association,
+  DataTypeAbstract,
+} from "sequelize";
+
+//
+//  Fixtures
+// ~~~~~~~~~~
+//
+
+type AnyAttributes = Object;
+
+let s         = new Sequelize( '' );
+let sequelize = s;
+let DataTypes = Sequelize;
+let User: Class<Model<AnyAttributes>>      = s.define( 'user', {} );
+let user      = User.build();
+let Task: Class<Model<AnyAttributes>>      = s.define( 'task', {} );
+let Group: Class<Model<AnyAttributes>>     = s.define( 'group', {} );
+let Comment: Class<Model<AnyAttributes>>   = s.define( 'comment', {} );
+let Post: Class<Model<AnyAttributes>>      = s.define( 'post', {} );
+let t: Transaction = (null: any);
+s.transaction().then( ( a ) => t = a );
+
+//
+//  Generics
+// ~~~~~~~~~~
+//
+
+interface GUserAttributes {
+  id? : number;
+  username? : string;
+}
+
+declare class GUserModel extends Model<GUserAttributes> {}
+let GUser: typeof GUserModel = s.define( 'user', { id: Sequelize.INTEGER, username : Sequelize.STRING });
+GUser.create({ id : 1, username : 'one' }).then( ( guser ) => guser.save() );
+
+let schema : DefineAttributes = {
+  key : { type : Sequelize.STRING, primaryKey : true },
+  value : Sequelize.STRING
+};
+
+s.define('user', schema);
+
+interface GTaskAttributes {
+  revision? : number;
+  name? : string;
+}
+declare class GTaskModel extends Model<GTaskAttributes> {
+  upRevision(): void;
+}
+let GTask: typeof GTaskModel = s.define( 'task', { revision : Sequelize.INTEGER, name : Sequelize.STRING });
+
+GUser.hasMany(GTask);
+
+GTask.create({ revision: 1, name: 'test' }).then( (gtask) => gtask.upRevision() );
+
+//
+//  Model.Options
+// ~~~~~~~~~~~~~~~
+//
+
+(GUser.options.name.singular: string);
+(GUser.options.name.plural: string);
+(GUser.options.timestamps: ?boolean);
+(GUser.options.paranoid: ?boolean);
+(GUser.options.underscored: ?boolean);
+(GUser.options.underscoredAll: ?boolean);
+(GUser.options.hasTrigger: ?boolean);
+(GUser.options.freezeTableName: ?boolean);
+
+//
+//  Associations
+// ~~~~~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/tree/v3.4.1/test/integration/associations
+//
+
+User.hasOne( Task );
+User.hasOne( Task, { foreignKey : 'primaryGroupId', as : 'primaryUsers' } );
+User.hasOne( Task, { foreignKey : 'userCoolIdTag' } );
+User.hasOne( Task, { foreignKey : 'userId', keyType : Sequelize.STRING, constraints : false } );
+Task.hasOne( User, { foreignKey : { name : 'taskId', field : 'task_id' } } );
+User.hasOne( Task, { foreignKey : { name : 'uid', allowNull : false } } );
+User.hasOne( Task, { onDelete : 'cascade' } );
+User.hasOne( Task, { onUpdate : 'cascade' } );
+User.hasOne( Task, { onDelete : 'cascade', hooks : true } );
+User.hasOne( Task, { foreignKey : { allowNull : false } } );
+User.hasOne( Task, { foreignKeyConstraint : true } );
+
+User.belongsTo( Task );
+User.belongsTo( Task, { foreignKey : 'primaryGroupId', as : 'primaryUsers' } );
+Task.belongsTo( User, { foreignKey : 'user_id' } );
+Task.belongsTo( User, { foreignKey : 'user_name', targetKey : 'username' } );
+User.belongsTo( User, { foreignKey : 'userId', keyType : Sequelize.STRING, constraints : false } );
+User.belongsTo( Post, { foreignKey : { name : 'AccountId', field : 'account_id' } } );
+Task.belongsTo( User, { foreignKey : { allowNull : false, name : 'uid' } } );
+Task.belongsTo( User, { constraints : false } );
+Task.belongsTo( User, { onDelete : 'cascade' } );
+Task.belongsTo( User, { onUpdate : 'restrict' } );
+User.belongsTo( User, {
+  as : 'parentBlocks',
+  foreignKey : 'child',
+  foreignKeyConstraint : true
+} );
+
+User.hasMany( User );
+User.hasMany( User, { foreignKey : 'primaryGroupId', as : 'primaryUsers' } );
+User.hasMany( Task, { foreignKey : 'userId' } );
+User.hasMany( Task, { foreignKey : 'userId', as : 'activeTasks', scope : { active : true } } );
+User.hasMany( Task, { foreignKey : 'userId', keyType : Sequelize.STRING, constraints : false } );
+User.hasMany( Task, { foreignKey : { name : 'uid', allowNull : false } } );
+User.hasMany( Task, { foreignKey : { allowNull : true } } );
+User.hasMany( Task, { as : 'Children' } );
+User.hasMany( Task, { as : { singular : 'task', plural : 'taskz' } } );
+User.hasMany( Task, { constraints : false } );
+User.hasMany( Task, { onDelete : 'cascade' } );
+User.hasMany( Task, { onUpdate : 'cascade' } );
+Post.hasMany( Task, { foreignKey : 'commentable_id', scope : { commentable : 'post' } } );
+User.hasMany( User, {
+  as : 'childBlocks',
+  foreignKey : 'parent',
+  foreignKeyConstraint : true
+} );
+
+User.belongsToMany( Task, { through : 'UserTasks' } );
+User.belongsToMany( User, { through : Task } );
+User.belongsToMany( Group, { as : 'groups', through : Task, foreignKey : 'id_user' } );
+User.belongsToMany( Task, { as : 'activeTasks', through : Task, scope : { active : true } } );
+User.belongsToMany( Task, { as : 'startedTasks', through : { model : Task, scope : { started : true } } } );
+User.belongsToMany( Group, { through : 'group_members', foreignKey : 'group_id', otherKey : 'member_id' } );
+User.belongsToMany( User, { as : 'Participants', through : User } );
+User.belongsToMany( Group, { through : 'user_places', foreignKey : 'user_id' } );
+User.belongsToMany( Group, {
+  through : 'user_projects',
+  as : 'Projects',
+  foreignKey : {
+    field : 'user_id',
+    name : 'userId'
+  },
+  otherKey : {
+    field : 'project_id',
+    name : 'projectId'
+  }
+} );
+User.belongsToMany( Task, { onDelete : 'RESTRICT', through : 'tasksusers' } );
+User.belongsToMany( Task, { constraints : false, through : 'tasksusers' } );
+User.belongsToMany( Task, { foreignKey : { name : 'user_id', defaultValue : 42 }, through : 'UserProjects' } );
+User.belongsToMany( Post, { through : User } );
+Post.belongsToMany( User, { as : 'categories', through : User, scope : { type : 'category' } } );
+Post.belongsToMany( User, { as : 'tags', through : User, scope : { type : 'tag' } } );
+Post.belongsToMany( User, {
+  through : {
+    model : User,
+    unique : false,
+    scope : {
+      taggable : 'post'
+    }
+  },
+  foreignKey : 'taggable_id',
+  constraints : false
+} );
+Post.belongsToMany( Post, { through : { model : Post, unique : false }, foreignKey : 'tag_id' } );
+Post.belongsToMany( Post, { as : 'Parents', through : 'Family', foreignKey : 'ChildId', otherKey : 'PersonId' } );
+
+//
+// Mixins
+// ~~~~~~
+//
+//  https://github.com/sequelize/sequelize/tree/v3.4.1/test/integration/associations
+//
+
+let Product: typeof ProductInstance = s.define('product', {});
+let product = Product.build();
+
+let Barcode: typeof BarcodeInstance = s.define('barcode', {});
+let barcode = Barcode.build();
+
+let Warehouse: typeof WarehouseInstance = s.define('warehouse', {});
+let warehouse = Warehouse.build();
+
+let Branch: typeof BranchInstance = s.define('branch', {});
+let branch = Branch.build();
+
+let WarehouseBranch: typeof WarehouseBranchInstance = s.define('warehouseBranch', {});
+
+let Customer: typeof CustomerInstance = s.define('customer', {});
+let customer = Customer.build();
+
+const ProductBarcode = Product.hasOne(Barcode);
+const BarcodeProduct = Barcode.belongsTo(Product);
+
+const WarehouseProducts = Warehouse.hasMany(Product);
+const ProductWarehouse = Product.belongsTo(Warehouse);
+
+const WarehouseBranches = Warehouse.belongsToMany(Branch, { through: WarehouseBranch });
+const BranchWarehouses = Branch.belongsToMany(Warehouse, { through: WarehouseBranch });
+
+Branch.belongsToMany(Customer, { through: 'branchCustomer' });
+Customer.belongsToMany(Branch, { through: 'branchCustomer' });
+
+// Metadata
+
+(Warehouse.associations.branch: Association<WarehouseInstance, BranchInstance>);
+(Warehouse.tableName: string);
+(Warehouse.rawAttributes.blah.type: DataTypeAbstract);
+(Warehouse.tableAttributes.blah.type: DataTypeAbstract);
+(Warehouse.attributes.blah.type: DataTypeAbstract);
+(Warehouse.primaryKeys.blah.type: DataTypeAbstract);
+
+Warehouse.getAssociations(WarehouseBranch)
+Warehouse.getAssociationForAlias(WarehouseBranch, 'blah')
+
+// hasOne
+product.getBarcode();
+product.getBarcode({ scope: null }).then(b => b && b.code);
+
+product.setBarcode(null);
+product.setBarcode(1);
+product.setBarcode(barcode);
+product.setBarcode(barcode, { save: true }).then(() => { });
+
+product.createBarcode();
+product.createBarcode({ id: 1, code: '1434-2' });
+product.createBarcode({ id: 1 }, { save: true, silent: true }).then(() => { });
+
+// belongsTo
+barcode.getProduct();
+barcode.getProduct({ scope: 'foo' }).then(p => p && p.name);
+
+barcode.setProduct(null);
+barcode.setProduct(1);
+barcode.setProduct(product);
+barcode.setProduct(product, { save: true }).then(() => { });
+
+barcode.createProduct({ id: 1, name: 'Crowbar' });
+barcode.createProduct({ id: 1 }, { save: true, silent: true }).then((product) => { });
+
+product.getWarehouse();
+product.getWarehouse({ scope: null }).then(w => w && w.capacity);
+
+product.setWarehouse(null);
+product.setWarehouse(1);
+product.setWarehouse(warehouse);
+product.setWarehouse(warehouse, { save: true }).then(() => { });
+
+product.createWarehouse();
+product.createWarehouse({ id: 1, capacity: 10000 });
+product.createWarehouse({ id: 1 }, { save: true, silent: true }).then(() => { });
+
+// hasMany
+warehouse.getProducts();
+warehouse.getProducts({ where: {}, scope: false });
+warehouse.getProducts({ where: {}, scope: false }).then((products) => products[0].id);
+
+warehouse.setProducts(null);
+warehouse.setProducts([product]);
+warehouse.setProducts([product], { validate: true }).then(() => { });
+
+warehouse.addProducts([product]);
+warehouse.addProducts([product, 2], { validate: false }).then(() => { });
+
+warehouse.addProduct(product);
+warehouse.addProduct(2, { validate: true }).then(() => { });
+
+warehouse.createProduct({ id: 1, name: 'baz' });
+warehouse.createProduct({ id: 1 }, { silent: true }).then((product) => { });
+
+warehouse.removeProducts();
+warehouse.removeProducts([product]);
+warehouse.removeProducts([product, 2], { validate: false }).then(() => { });
+
+warehouse.removeProduct(product);
+warehouse.removeProduct(2, { validate: true }).then(() => { });
+
+warehouse.hasProducts([product]);
+warehouse.hasProducts([product, 2], { scope: 'bar' }).then((result: boolean) => { });
+
+warehouse.hasProduct(product);
+warehouse.hasProduct(2, { scope: 'baz' }).then((result: boolean) => { });
+
+warehouse.countProducts();
+warehouse.countProducts({ scope: 'baz' }).then((result: number) => { });
+
+// belongsToMany <Model>
+warehouse.getBranches();
+warehouse.getBranches({ where: {} });
+warehouse.getBranches({ where: {} }).then((branches) => branches[0].rank);
+
+warehouse.setBranches(null);
+warehouse.setBranches([branch]);
+warehouse.setBranches([branch, 2], { validate: true, through: { distance: 1 } }).then(() => { });
+
+warehouse.addBranches([branch]);
+warehouse.addBranches([branch, 2], { validate: false, through: { distance: 1 } }).then(() => { });
+
+warehouse.addBranch(branch);
+warehouse.addBranch(2, { validate: true, through: { distance: 1 } }).then(() => { });
+
+warehouse.createBranch();
+warehouse.createBranch({ id: 1, address: 'baz' });
+warehouse.createBranch({ id: 1 }, { silent: true, through: { distance: 1 } }).then((branch) => { });
+
+warehouse.removeBranches();
+warehouse.removeBranches([branch]);
+warehouse.removeBranches([branch, 2], { validate: false }).then(() => { });
+
+warehouse.removeBranch(branch);
+warehouse.removeBranch(2, { validate: true }).then(() => { });
+
+warehouse.hasBranches([branch]);
+warehouse.hasBranches([branch, 2], { scope: 'bar' }).then((result: boolean) => { });
+
+warehouse.hasBranch(branch);
+warehouse.hasBranch(2, { scope: 'baz' }).then((result: boolean) => { });
+
+warehouse.countBranches();
+warehouse.countBranches({ scope: 'baz' }).then((result: number) => { });
+
+// belongsToMany <void>
+customer.getBranches();
+customer.getBranches({ where: {} });
+customer.getBranches({ where: {} }).then((branches) => branches[0].rank);
+
+customer.setBranches(null);
+customer.setBranches([branch]);
+customer.setBranches([branch, 2], { validate: true }).then(() => { });
+
+customer.addBranches([branch]);
+customer.addBranches([branch, 2], { validate: false }).then(() => { });
+
+customer.addBranch(branch);
+customer.addBranch(2, { validate: true }).then(() => { });
+
+customer.createBranch();
+customer.createBranch({ id: 1, address: 'baz' });
+customer.createBranch({ id: 1 }, { silent: true }).then((branch) => { });
+
+customer.removeBranches();
+customer.removeBranches([branch]);
+customer.removeBranches([branch, 2], { validate: false }).then(() => { });
+
+customer.removeBranch(branch);
+customer.removeBranch(2, { validate: true }).then(() => { });
+
+customer.hasBranches([branch]);
+customer.hasBranches([branch, 2], { scope: 'bar' }).then((result: boolean) => { });
+
+customer.hasBranch(branch);
+customer.hasBranch(2, { scope: 'baz' }).then((result: boolean) => { });
+
+customer.countBranches();
+customer.countBranches({ scope: 'baz' }).then((result: number) => { });
+
+// query on associations
+
+WarehouseProducts.get(warehouse).then((products: Array<ProductInstance>) => {})
+WarehouseProducts.get([warehouse], {scope: 'baz'}).then((products: { [id: number]: ProductInstance, ... }) => {})
+WarehouseProducts.count(warehouse).then((count: number) => {})
+WarehouseProducts.count(warehouse, {scope: 'baz'}).then((count: number) => {})
+WarehouseProducts.has(warehouse, [product, 2]).then((result: boolean) => {})
+WarehouseProducts.has(warehouse, [product, 2], {scope: 'baz'}).then((result: boolean) => {})
+WarehouseProducts.set(warehouse, [product, 2]).then((result: WarehouseInstance) => {})
+WarehouseProducts.set(warehouse, [product, 2], {where: {}, scope: 'baz'}).then((result: WarehouseInstance) => {})
+WarehouseProducts.remove(warehouse, [product, 2]).then((result: typeof WarehouseProducts) => {})
+WarehouseProducts.remove(warehouse, [product, 2], {where: {}, individualHooks: true}).then((result: typeof WarehouseProducts) => {})
+WarehouseProducts.create(warehouse, {
+  name: 'doodad',
+  price: 2.50,
+}, {individualHooks: true}).then((result: ProductInstance) => {})
+
+WarehouseBranches.get(warehouse).then((branches: Array<BranchInstance>) => {})
+WarehouseBranches.get(warehouse, {scope: 'baz'}).then((branches: Array<BranchInstance>) => {})
+WarehouseBranches.count(warehouse).then((count: number) => {})
+WarehouseBranches.count(warehouse, {scope: 'baz'}).then((count: number) => {})
+WarehouseBranches.has(warehouse, [branch, 2]).then((result: boolean) => {})
+WarehouseBranches.has(warehouse, [branch, 2], {scope: 'blah'}).then((result: boolean) => {})
+WarehouseBranches.set(warehouse, [branch, 2]).then((result: any) => {})
+WarehouseBranches.set(warehouse, [branch, 2], {scope: 'blah'}).then((result: any) => {})
+WarehouseBranches.remove(warehouse, [branch, 2]).then(() => {})
+WarehouseBranches.remove(warehouse, [branch, 2], {scope: 'blah'}).then(() => {})
+WarehouseBranches.create(warehouse, {
+  address: 'somewhere',
+  rank: 12,
+}, {
+  through: {
+    distance: 4.5,
+  },
+  individualHooks: true,
+}).then((result: Branch) => {})
+
+ProductBarcode.get(product).then((barcode: BarcodeInstance) => {})
+ProductBarcode.get(product).then((barcode: BarcodeInstance) => {})
+ProductBarcode.get([product]).then((barcodes: { [id: number]: BarcodeInstance, ... }) => {})
+ProductBarcode.get([product], {scope: 'boo'})
+ProductBarcode.set(product, barcode)
+ProductBarcode.set(product, 1, {scope: 'bar'})
+ProductBarcode.create(product, {
+  code: 'blah',
+  dateIssued: new Date(),
+}).then((barcode: BarcodeInstance) => {})
+ProductBarcode.create(product, {
+  code: 'blah',
+  dateIssued: new Date(),
+}, {
+  save: true,
+})
+
+ProductWarehouse.get(product).then((warehouse: WarehouseInstance) => {})
+ProductWarehouse.get([product]).then((warehouses: { [id: number]: WarehouseInstance, ... }) => {})
+ProductWarehouse.get([product], {scope: 'boo'})
+ProductWarehouse.set(product, warehouse)
+ProductWarehouse.set(product, 1, {scope: 'bar'})
+ProductWarehouse.create(product, {
+  address: 'somewhere',
+  capacity: 10000,
+}).then((warehouse: WarehouseInstance) => {})
+ProductWarehouse.create(product, {
+  address: 'somewhere',
+  capacity: 10000,
+}, {
+  save: true,
+})
+
+// query with associations
+
+Warehouse.findAll({include: [{association: WarehouseProducts}]}).then((warehouses: Array<WarehouseInstance>) => {})
+Warehouse.findAll({include: [{association: WarehouseBranches}]}).then((warehouses: Array<WarehouseInstance>) => {})
+Branch.findAll({include: [{association: BranchWarehouses}]}).then((branch: Array<BranchInstance>) => {})
+Product.findOne({include: [{association: ProductWarehouse}]}).then((product: ?Product) => {})
+
+type ProductAttributes = {
+  id?: number,
+  name?: string,
+  price?: number,
+  ...
+};
+
+declare class ProductInstance extends Model<ProductAttributes> {
+  id?: number;
+  name?: string;
+  price?: number;
+
+  // hasOne association mixins:
+  getBarcode: HasOneGetOne<BarcodeInstance>;
+  setBarcode: HasOneSetOne<BarcodeInstance, number>;
+  createBarcode: HasOneCreateOne<BarcodeAttributes>;
+
+  // belongsTo association mixins:
+  getWarehouse: BelongsToGetOne<WarehouseInstance>;
+  setWarehouse: BelongsToSetOne<WarehouseInstance, number>;
+  createWarehouse: BelongsToCreateOne<WarehouseAttributes>;
+};
+
+type BarcodeAttributes = {
+  id?: number,
+  code?: string,
+  dateIssued?: Date,
+  ...
+};
+
+declare class BarcodeInstance extends Model<BarcodeAttributes> {
+  id?: number;
+  code?: string;
+  dateIssued?: Date;
+  // belongsTo association mixins:
+  getProduct: BelongsToGetOne<ProductInstance>;
+  setProduct: BelongsToSetOne<ProductInstance, number>;
+  createProduct: BelongsToCreateOne<ProductAttributes>;
+};
+
+type WarehouseAttributes = {
+  id?: number,
+  address?: string,
+  capacity?: number,
+  ...
+};
+
+declare class WarehouseInstance extends Model<WarehouseAttributes> {
+  id?: number;
+  address?: string;
+  capacity?: number;
+  // hasMany association mixins:
+  getProducts: HasManyGetMany<ProductInstance>;
+  setProducts: HasManySetMany<ProductInstance, number>;
+  addProducts: HasManyAddMany<ProductInstance, number>;
+  addProduct: HasManyAddOne<ProductInstance, number>;
+  createProduct: HasManyCreateOne<ProductAttributes, ProductInstance>;
+  removeProduct: HasManyRemoveOne<ProductInstance, number>;
+  removeProducts: HasManyRemoveMany<ProductInstance, number>;
+  hasProduct: HasManyHasOne<ProductInstance, number>;
+  hasProducts: HasManyHasMany<ProductInstance, number>;
+  countProducts: HasManyCount;
+
+  // belongsToMany association mixins:
+  getBranches: BelongsToManyGetMany<BranchInstance>;
+  setBranches: BelongsToManySetMany<BranchInstance, number, WarehouseBranchAttributes>;
+  addBranches: BelongsToManyAddMany<BranchInstance, number, WarehouseBranchAttributes>;
+  addBranch: BelongsToManyAddOne<BranchInstance, number, WarehouseBranchAttributes>;
+  createBranch: BelongsToManyCreateOne<BranchAttributes, BranchInstance, WarehouseBranchAttributes>;
+  removeBranch: BelongsToManyRemoveOne<BranchInstance, number>;
+  removeBranches: BelongsToManyRemoveMany<BranchInstance, number>;
+  hasBranch: BelongsToManyHasOne<BranchInstance, number>;
+  hasBranches: BelongsToManyHasMany<BranchInstance, number>;
+  countBranches: BelongsToManyCount;
+};
+
+type BranchAttributes = {
+  id?: number,
+  address?: string,
+  rank?: number,
+  ...
+};
+
+declare class BranchInstance extends Model<BranchAttributes> {
+  id?: number;
+  address?: string;
+  rank?: number;
+
+  // belongsToMany association mixins:
+  getWarehouses: BelongsToManyGetMany<WarehouseInstance>;
+  setWarehouses: BelongsToManySetMany<WarehouseInstance, number, WarehouseBranchAttributes>;
+  addWarehouses: BelongsToManyAddMany<WarehouseInstance, number, WarehouseBranchAttributes>;
+  addWarehouse: BelongsToManyAddOne<WarehouseInstance, number, WarehouseBranchAttributes>;
+  createWarehouse: BelongsToManyCreateOne<WarehouseAttributes, WarehouseInstance, WarehouseBranchAttributes>;
+  removeWarehouse: BelongsToManyRemoveOne<WarehouseInstance, number>;
+  removeWarehouses: BelongsToManyRemoveMany<WarehouseInstance, number>;
+  hasWarehouse: BelongsToManyHasOne<WarehouseInstance, number>;
+  hasWarehouses: BelongsToManyHasMany<WarehouseInstance, number>;
+  countWarehouses: BelongsToManyCount;
+
+  // belongsToMany association mixins:
+  getCustomers: BelongsToManyGetMany<CustomerInstance>;
+  setCustomers: BelongsToManySetMany<CustomerInstance, number, void>;
+  addCustomers: BelongsToManyAddMany<CustomerInstance, number, void>;
+  addCustomer: BelongsToManyAddOne<CustomerInstance, number, void>;
+  createCustomer: BelongsToManyCreateOne<CustomerAttributes, CustomerInstance, void>;
+  removeCustomer: BelongsToManyRemoveOne<CustomerInstance, number>;
+  removeCustomers: BelongsToManyRemoveMany<CustomerInstance, number>;
+  hasCustomer: BelongsToManyHasOne<CustomerInstance, number>;
+  hasCustomers: BelongsToManyHasMany<CustomerInstance, number>;
+  countCustomers: BelongsToManyCount;
+};
+
+type WarehouseBranchAttributes = { distance?: number, ... };
+
+declare class WarehouseBranchInstance extends Model<WarehouseBranchAttributes> {
+  distance?: number;
+};
+
+type CustomerAttributes = {
+  id?: number,
+  fullname?: string,
+  credit?: number,
+  ...
+};
+
+declare class CustomerInstance extends Model<CustomerAttributes> {
+  id?: number;
+  fullname?: string;
+  credit?: number;
+  // belongsToMany association mixins:
+  getBranches: BelongsToManyGetMany<BranchInstance>;
+  setBranches: BelongsToManySetMany<BranchInstance, number, void>;
+  addBranches: BelongsToManyAddMany<BranchInstance, number, void>;
+  addBranch: BelongsToManyAddOne<BranchInstance, number, void>;
+  createBranch: BelongsToManyCreateOne<BranchAttributes, BranchInstance, void>;
+  removeBranch: BelongsToManyRemoveOne<BranchInstance, number>;
+  removeBranches: BelongsToManyRemoveMany<BranchInstance, number>;
+  hasBranch: BelongsToManyHasOne<BranchInstance, number>;
+  hasBranches: BelongsToManyHasMany<BranchInstance, number>;
+  countBranches: BelongsToManyCount;
+};
+
+//
+//  DataTypes
+// ~~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/unit/sql/data-types.test.js
+//
+
+Sequelize.STRING;
+Sequelize.STRING( 1234 );
+Sequelize.STRING( { length : 1234 } );
+Sequelize.STRING( 1234 ).BINARY;
+Sequelize.STRING.BINARY;
+Sequelize.TEXT;
+Sequelize.TEXT( 'tiny' );
+Sequelize.TEXT( { length : 'tiny' } );
+Sequelize.TEXT( 'medium' );
+Sequelize.TEXT( 'long' );
+Sequelize.CHAR;
+Sequelize.CHAR( 12 );
+Sequelize.CHAR( { length : 12 } );
+Sequelize.CHAR( 12 ).BINARY;
+Sequelize.CHAR.BINARY;
+Sequelize.BOOLEAN;
+Sequelize.DATE;
+Sequelize.DATE(6);
+Sequelize.UUID;
+Sequelize.UUIDV1;
+Sequelize.UUIDV4;
+Sequelize.NOW;
+Sequelize.INTEGER;
+Sequelize.INTEGER.UNSIGNED;
+Sequelize.INTEGER.UNSIGNED.ZEROFILL;
+Sequelize.INTEGER( 11 );
+Sequelize.INTEGER( { length : 11 } );
+Sequelize.INTEGER( 11 ).UNSIGNED;
+Sequelize.INTEGER( 11 ).UNSIGNED.ZEROFILL;
+Sequelize.INTEGER( 11 ).ZEROFILL;
+Sequelize.INTEGER( 11 ).ZEROFILL.UNSIGNED;
+Sequelize.BIGINT;
+Sequelize.BIGINT.UNSIGNED;
+Sequelize.BIGINT.UNSIGNED.ZEROFILL;
+Sequelize.BIGINT( 11 );
+Sequelize.BIGINT( { length : 11 } );
+Sequelize.BIGINT( 11 ).UNSIGNED;
+Sequelize.BIGINT( 11 ).UNSIGNED.ZEROFILL;
+Sequelize.BIGINT( 11 ).ZEROFILL;
+Sequelize.BIGINT( 11 ).ZEROFILL.UNSIGNED;
+Sequelize.REAL.UNSIGNED;
+Sequelize.REAL( 11 );
+Sequelize.REAL( { length : 11 } );
+Sequelize.REAL( 11 ).UNSIGNED;
+Sequelize.REAL( 11 ).UNSIGNED.ZEROFILL;
+Sequelize.REAL( 11 ).ZEROFILL;
+Sequelize.REAL( 11 ).ZEROFILL.UNSIGNED;
+Sequelize.REAL( 11, 12 );
+Sequelize.REAL( 11, 12 ).UNSIGNED;
+Sequelize.REAL( { length : 11, decimals : 12 } ).UNSIGNED;
+Sequelize.REAL( 11, 12 ).UNSIGNED.ZEROFILL;
+Sequelize.REAL( 11, 12 ).ZEROFILL;
+Sequelize.REAL( 11, 12 ).ZEROFILL.UNSIGNED;
+Sequelize.DOUBLE;
+Sequelize.DOUBLE.UNSIGNED;
+Sequelize.DOUBLE( 11 );
+Sequelize.DOUBLE( 11 ).UNSIGNED;
+Sequelize.DOUBLE( { length : 11 } ).UNSIGNED;
+Sequelize.DOUBLE( 11 ).UNSIGNED.ZEROFILL;
+Sequelize.DOUBLE( 11 ).ZEROFILL;
+Sequelize.DOUBLE( 11 ).ZEROFILL.UNSIGNED;
+Sequelize.DOUBLE( 11, 12 );
+Sequelize.DOUBLE( 11, 12 ).UNSIGNED;
+Sequelize.DOUBLE( 11, 12 ).UNSIGNED.ZEROFILL;
+Sequelize.DOUBLE( 11, 12 ).ZEROFILL;
+Sequelize.DOUBLE( 11, 12 ).ZEROFILL.UNSIGNED;
+Sequelize.FLOAT;
+Sequelize.FLOAT.UNSIGNED;
+Sequelize.FLOAT( 11 );
+Sequelize.FLOAT( 11 ).UNSIGNED;
+Sequelize.FLOAT( 11 ).UNSIGNED.ZEROFILL;
+Sequelize.FLOAT( 11 ).ZEROFILL;
+Sequelize.FLOAT( { length : 11 } ).ZEROFILL;
+Sequelize.FLOAT( 11 ).ZEROFILL.UNSIGNED;
+Sequelize.FLOAT( 11, 12 );
+Sequelize.FLOAT( 11, 12 ).UNSIGNED;
+Sequelize.FLOAT( { length : 11, decimals : 12 } ).UNSIGNED;
+Sequelize.FLOAT( 11, 12 ).UNSIGNED.ZEROFILL;
+Sequelize.FLOAT( 11, 12 ).ZEROFILL;
+Sequelize.FLOAT( 11, 12 ).ZEROFILL.UNSIGNED;
+Sequelize.NUMERIC;
+Sequelize.NUMERIC( 15, 5 );
+Sequelize.DECIMAL;
+Sequelize.DECIMAL( 10, 2 );
+Sequelize.DECIMAL( { precision : 10, scale : 2 } );
+Sequelize.DECIMAL( 10 );
+Sequelize.DECIMAL( { precision : 10 } );
+Sequelize.ENUM( 'value 1', 'value 2' );
+Sequelize.BLOB;
+Sequelize.BLOB( 'tiny' );
+Sequelize.BLOB( 'medium' );
+Sequelize.BLOB( { length : 'medium' } );
+Sequelize.BLOB( 'long' );
+Sequelize.ARRAY( Sequelize.STRING );
+Sequelize.ARRAY( Sequelize.STRING( 100 ) );
+Sequelize.ARRAY( Sequelize.INTEGER );
+Sequelize.ARRAY( Sequelize.HSTORE );
+Sequelize.ARRAY( Sequelize.ARRAY( Sequelize.STRING ) );
+Sequelize.ARRAY( Sequelize.TEXT );
+Sequelize.ARRAY( Sequelize.DATE );
+Sequelize.ARRAY( Sequelize.BOOLEAN );
+Sequelize.ARRAY( Sequelize.DECIMAL );
+Sequelize.ARRAY( Sequelize.DECIMAL( 6 ) );
+Sequelize.ARRAY( Sequelize.DECIMAL( 6, 4 ) );
+Sequelize.ARRAY( Sequelize.DOUBLE );
+Sequelize.ARRAY( Sequelize.REAL );
+Sequelize.ARRAY( Sequelize.JSON );
+Sequelize.ARRAY( Sequelize.JSONB );
+Sequelize.GEOMETRY;
+Sequelize.GEOMETRY( 'POINT' );
+Sequelize.GEOMETRY( 'LINESTRING' );
+Sequelize.GEOMETRY( 'POLYGON' );
+Sequelize.GEOMETRY( 'POINT', 4326 );
+Sequelize.VIRTUAL;
+Sequelize.VIRTUAL( Sequelize.STRING );
+Sequelize.VIRTUAL( Sequelize.DATE , ['property1', 'property2']);
+new Sequelize.VIRTUAL( Sequelize.STRING );
+new Sequelize.VIRTUAL( Sequelize.DATE , ['property1', 'property2']);
+
+//
+//  Deferrable
+// ~~~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/sequelize/deferrable.test.js
+//
+
+Sequelize.Deferrable.NOT;
+Sequelize.Deferrable.INITIALLY_IMMEDIATE;
+Sequelize.Deferrable.INITIALLY_DEFERRED;
+Sequelize.Deferrable.SET_DEFERRED;
+Sequelize.Deferrable.SET_DEFERRED( ['taskTableName_user_id_fkey'] );
+Sequelize.Deferrable.SET_IMMEDIATE;
+Sequelize.Deferrable.SET_IMMEDIATE( ['taskTableName_user_id_fkey'] );
+
+//
+//  Errors
+// ~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/error.test.js
+//
+
+Sequelize.Error;
+Sequelize.ValidationError;
+s.Error;
+s.ValidationError;
+new s.ValidationError( 'Validation Error', [
+  new s.ValidationErrorItem( '<field name> cannot be null', 'notNull Violation', '<field name>', 'value' )
+  , new s.ValidationErrorItem( '<field name> cannot be an array or an object', 'string violation',
+    '<field name>', 'value' )
+] );
+new s.Error();
+new s.ValidationError('message');
+new s.ValidationErrorItem( 'invalid', 'type', 'first_name', 'value' );
+new s.ValidationErrorItem( 'invalid', 'type', 'last_name', 'value' );
+new s.DatabaseError( new Error( 'original database error message' ) );
+new s.ConnectionError( new Error( 'original connection error message' ) );
+new s.ConnectionRefusedError( new Error( 'original connection error message' ) );
+new s.AccessDeniedError( new Error( 'original connection error message' ) );
+new s.HostNotFoundError( new Error( 'original connection error message' ) );
+new s.HostNotReachableError( new Error( 'original connection error message' ) );
+new s.InvalidConnectionError( new Error( 'original connection error message' ) );
+new s.ConnectionTimedOutError( new Error( 'original connection error message' ) );
+new s.EmptyResultError();
+
+const uniqueConstraintError: Sequelize.ValidationError = new s.UniqueConstraintError({});
+
+//
+//  Hooks
+// ~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/hooks.test.js
+//
+
+User.addHook( 'afterCreate', function( instance : Model<any>, options : Object, next : Function ) { next(); } );
+User.addHook( 'afterCreate', 'myHook', function( instance : Model<any>, options : Object, next : Function) { next(); } );
+s.addHook( 'beforeInit', function( config : Object, options : Object ) { } );
+User.hook( 'afterCreate', 'myHook', function( instance : Model<any>, options : Object, next : Function) { next(); } );
+User.hook( 'afterCreate', 'myHook', function( instance : Model<any>, options : Object, next : Function ) { next(); } );
+
+User.removeHook( 'afterCreate', 'myHook' );
+
+User.hasHook( 'afterCreate' );
+User.hasHooks( 'afterCreate' );
+
+User.beforeValidate( function( user, options ) { user.isNewRecord; } );
+User.beforeValidate( 'myHook', function( user, options ) { user.isNewRecord; } );
+
+User.afterValidate( function( user, options ) { user.isNewRecord; } );
+User.afterValidate( 'myHook', function( user, options ) { user.isNewRecord; } );
+
+User.beforeCreate( function( user, options ) { user.isNewRecord; } );
+User.beforeCreate( function( user, options, fn ) {fn();} );
+User.beforeCreate( 'myHook', function( user, options ) { user.isNewRecord; } );
+
+User.afterCreate( function( user, options ) { user.isNewRecord; } );
+User.afterCreate( function( user, options, fn ) {fn();} );
+User.afterCreate( 'myHook', function( user, options ) { user.isNewRecord; } );
+
+User.beforeDestroy( function( user, options ) {throw new Error( 'Whoops!' );} );
+User.beforeDestroy( function( user, options, fn ) {fn();} );
+User.beforeDestroy( 'myHook', function( user, options ) {throw new Error( 'Whoops!' );} );
+User.beforeDelete( function( user, options ) {throw new Error( 'Whoops!' );} );
+User.beforeDelete( 'myHook', function( user, options ) {throw new Error( 'Whoops!' );} );
+
+User.afterDestroy( function( user, options ) {throw new Error( 'Whoops!' );} );
+User.afterDestroy( 'myHook', function( user, options ) {throw new Error( 'Whoops!' );} );
+User.afterDestroy( function( user, options, fn ) {fn();} );
+User.afterDelete( function( user, options ) {throw new Error( 'Whoops!' );} );
+User.afterDelete( 'myHook', function( user, options ) {throw new Error( 'Whoops!' );} );
+
+User.beforeUpdate( function( user, options ) {throw new Error( 'Whoops!' ); } );
+User.beforeUpdate( 'myHook', function( user, options ) {throw new Error( 'Whoops!' ); } );
+
+User.afterUpdate( function( user, options ) {throw new Error( 'Whoops!' );} );
+User.afterUpdate( 'myHook', function( user, options ) {throw new Error( 'Whoops!' );} );
+
+User.beforeUpsert( function( user, options ) { throw new Error('Whoops'); } );
+User.beforeUpsert( 'myHook', function( user, options ) { throw new Error('Whoops'); } );
+
+User.afterUpsert( function( result, options ) { throw new Error('Whoops'); } );
+User.afterUpsert( 'myHook', function( result, options ) { throw new Error('Whoops'); } );
+
+User.beforeBulkCreate( function( daos, options ) { throw new Error( 'Whoops!' );} );
+User.beforeBulkCreate( 'myHook', function( daos, options ) { throw new Error( 'Whoops!' );} );
+User.beforeBulkCreate( function( daos, options, fn ) {fn();} );
+
+User.afterBulkCreate( function( daos, options ) {throw new Error( 'Whoops!' ); } );
+User.afterBulkCreate( 'myHook', function( daos, options ) {throw new Error( 'Whoops!' ); } );
+User.afterBulkCreate( function( daos, options, fn ) {fn();} );
+
+User.beforeBulkDestroy( function( options ) {throw new Error( 'Whoops!' );} );
+User.beforeBulkDestroy( function( options, fn ) {fn();} );
+User.beforeBulkDestroy( 'myHook', function( options, fn ) {fn();} );
+User.beforeBulkDelete( 'myHook', function( options, fn ) {fn();} );
+
+User.afterBulkDestroy( function( options ) {throw new Error( 'Whoops!' );} );
+User.afterBulkDestroy( function( options, fn ) {fn();} );
+User.afterBulkDestroy( 'myHook', function( options, fn ) {fn();} );
+User.afterBulkDelete( 'myHook', function( options, fn ) {fn();} );
+
+User.beforeBulkUpdate( function( options ) {throw new Error( 'Whoops!' );} );
+User.beforeBulkUpdate( 'myHook', function( options ) {throw new Error( 'Whoops!' );} );
+
+User.afterBulkUpdate( function( options ) {throw new Error( 'Whoops!' );} );
+User.afterBulkUpdate( 'myHook', function( options ) {throw new Error( 'Whoops!' );} );
+
+User.beforeFind( function( options ) {} );
+User.beforeFind( 'myHook', function( options ) {} );
+
+User.beforeFindAfterExpandIncludeAll( function( options ) {} );
+User.beforeFindAfterExpandIncludeAll( 'myHook', function( options ) {} );
+
+User.beforeFindAfterOptions( function( options ) {} );
+User.beforeFindAfterOptions( 'myHook', function( options ) {} );
+
+User.afterFind( function( user ) {} );
+User.afterFind( 'myHook', function( user ) {} );
+
+User.beforeSync( function( options ) {} );
+User.beforeSync( 'myHook', function( options ) {} );
+
+User.afterSync( function( options ) {} );
+User.afterSync( 'myHook', function( options ) {} );
+
+s.beforeDefine( function( attributes, options ) {} );
+s.beforeDefine( 'myHook', function( attributes, options ) {} );
+
+s.afterDefine( function( model ) {} );
+s.afterDefine( 'myHook', function( model ) {} );
+
+s.beforeInit( function( config, options ) {} );
+s.beforeInit( 'myHook', function( attributes, options ) {} );
+
+s.afterInit( function( model ) {} );
+s.afterInit( 'myHook', function( model ) {} );
+
+s.beforeBulkSync( function( options ) {} );
+s.beforeBulkSync( 'myHook', function( options ) {} );
+
+s.afterBulkSync( function( options ) {} );
+s.afterBulkSync( 'myHook', function( options ) {} );
+
+s.define( 'User', {}, {
+  hooks : {
+    beforeValidate : function( user, options, fn ) {fn();},
+    afterValidate : function( user, options, fn ) {fn();},
+    beforeCreate : function( user, options, fn ) {fn();},
+    afterCreate : function( user, options, fn ) {fn();},
+    beforeDestroy : function( user, options, fn ) {fn();},
+    afterDestroy : function( user, options, fn ) {fn();},
+    beforeDelete : function( user, options, fn ) {fn();},
+    afterDelete : function( user, options, fn ) {fn();},
+    beforeUpdate : function( user, options, fn ) {fn();},
+    afterUpdate : function( user, options, fn ) {fn();}
+  }
+} );
+
+//
+//  Instance
+// ~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/instance.test.js
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/instance/update.test.js
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/instance/values.test.js
+//
+
+user.isNewRecord = true;
+
+user.Model.build( { a : 'b' } );
+
+user.sequelize.close();
+
+user.where();
+
+user.getDataValue( '' );
+
+user.setDataValue( '', '' );
+user.setDataValue( '', {} );
+
+user.get( 'aNumber', { plain : true, clone : true } );
+user.get();
+
+user.set( 'email', 'B' );
+user.set( { name : 'B', bio : 'B' } ).save().then( ( p ) => p );
+user.set( 'birthdate', new Date() );
+user.set( { id : 1, t : 'c', q : [{ id : 1, n : 'a' }, { id : 2, n : 'Beta' }], u : { id : 1, f : 'b', l : 'd' } } );
+user.setAttributes( { a : 3 } );
+user.setAttributes( { id : 1, a : 'n', c : [{ id : 1 }, { id : 2, f : 'e' }], x : { id : 1, f : 'h', l : 'd' } } );
+
+user.changed( 'name' );
+user.changed();
+
+user.previous( 'name' );
+
+user.save().then( ( p ) => p );
+user.save( { fields : ['a'] } ).then( ( p ) => p );
+user.save( { transaction : t } );
+
+user.reload();
+user.reload( { attributes : ['bNumber'] } );
+user.reload( { transaction : t } );
+
+user.validate();
+
+user.update( { bNumber : 2 }, { where : { id : 1 } } );
+user.update( { username : 'userman' }, { silent : true } );
+user.update( { username : 'yolo' }, { logging : function() { } } );
+user.update( { username : 'bar' }, { where : { username : 'foo' }, transaction : t } ).then( ( p ) => p );
+user.updateAttributes( { a : 3 } ).then( ( p ) => p );
+user.updateAttributes( { a : 3 }, { fields : ['secretValue'], logging : function(  ) {} } );
+
+user.destroy().then( ( p ) => p );
+user.destroy( { logging : function(  ) {} } );
+user.destroy( { transaction : t } ).then( ( p ) => p );
+
+user.restore();
+
+user.increment( 'number', { by : 2 } ).then( ( p ) => p );
+user.increment( ['aNumber'], { by : 2, where : { bNumber : 1 } } ).then( ( p ) => p );
+user.increment( ['aNumber'], { by : 2 } ).then( ( p ) => p );
+user.increment( 'aNumber' ).then( ( p ) => p );
+user.increment( { 'aNumber' : 1, 'bNumber' : 2 } ).then( ( p ) => p );
+user.increment( 'number', { by : 2, transaction : t } ).then( ( p ) => p );
+
+user.decrement( 'aNumber', { by : 2 } ).then( ( p ) => p );
+user.decrement( ['aNumber'], { by : 2 } ).then( ( p ) => p );
+user.decrement( 'aNumber' ).then( ( p ) => p );
+user.decrement( { 'aNumber' : 1, 'bNumber' : 2 } ).then( ( p ) => p );
+user.decrement( 'number', { by : 2, transaction : t } ).then( ( p ) => p );
+
+user.equals( user );
+
+user.equalsOneOf( [user, user] );
+
+user.toJSON();
+
+
+//  Model
+// ~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/model.test.js
+//
+
+User.removeAttribute( 'id' );
+
+User.sync( { force : true } ).then( function() { } );
+User.sync( { force : true, logging : function() { } } );
+
+User.drop();
+
+User.schema( 'special' );
+User.schema( 'special' ).create( { age : 3 }, { logging : function(  ) {} } );
+
+User.getTableName();
+
+User.addScope('lowAccess', { where : { parent_id : 2 } });
+User.addScope('lowAccess', { where : { parent_id : 2 } }, { override: true });
+User.addScope('lowAccessWithParam', function(id: number) {
+  return { where : { parent_id : id } }
+} );
+
+User.scope( 'lowAccess' ).count();
+User.scope( [ 'lowAccess', { method: ['lowAccessWithParam', 2] } ] )
+
+User.findAll();
+User.findAll( { where : { data : { employment : null } } } );
+User.findAll( { where : { aNumber : { gte : 10 } } } ).then( ( u ) => u[0].isNewRecord );
+User.findAll( { where : [s.or( { u : 'b' }, { u : ';' } ), s.and( { id : [1, 2] } )], include : [{ model : User }] } );
+User.findAll( {
+  where : [s.or( { a : 'b' }, { c : 'd' } ), s.and( { id : [1, 2, 3] },
+    s.or( { deletedAt : null }, { deletedAt : { gt : new Date( 0 ) } } ) )]
+} );
+User.findAll( { paranoid : false, where : [' IS NOT NULL '], include : [{ model : User }] } );
+User.findAll( { include : [{ model : Task, paranoid: false }] } );
+User.findAll( { transaction : t } );
+User.findAll( { where : { data : { name : { last : 's' }, employment : { $ne : 'a' } } }, order : [['id', 'ASC']] } );
+User.findAll( { where : { username : ['boo', 'boo2'] } } );
+User.findAll( { where : { username : { like : '%2' } } } );
+User.findAll( { where : { theDate : { '..' : ['2013-01-02', '2013-01-11'] } } } );
+User.findAll( { where : { intVal : { '!..' : [8, 10] } } } );
+User.findAll( { where : { theDate : { between : ['2013-01-02', '2013-01-11'] } } } );
+User.findAll( { where : { theDate : { between : ['2013-01-02', '2013-01-11'] }, intVal : 10 } } );
+User.findAll( { where : { theDate : { between : ['2012-12-10', '2013-01-02'] } } } );
+User.findAll( { where : { theDate : { nbetween : ['2013-01-04', '2013-01-20'] } } } );
+User.findAll( { order : [s.col( 'name' )] } );
+User.findAll( { order : [['theDate', 'DESC']] } );
+User.findAll( { include : [User], order : [[User, User, 'numYears', 'c']] } );
+User.findAll( { include : [{ model : User, include : [User, { model : User, as : 'residents' }] }] } );
+User.findAll( { order : [[User, { model : User, as : 'residents' }, 'lastName', 'c']] } );
+User.findAll( { include : [User], order : [[User, 'name', 'c']] } );
+User.findAll( { include : [{ all : 'HasMany', attributes : ['name'] }] } );
+User.findAll( { include : [{ all : true }, { model : User, attributes : ['id'] }] } );
+User.findAll( { include : [{ all : 'BelongsTo' }] } );
+User.findAll( { include : [{ all : true }] } );
+User.findAll( { where : { username : 'barfooz' }, raw : true } );
+User.findAll( { where : { name : 'worker' }, include : [{ model : User, as : 'ToDos' }] } );
+User.findAll( { where : { user_id : 1 }, attributes : ['a', 'b'], include : [{ model : User, attributes : ['c'] }] } );
+User.findAll( { order : s.literal( 'email =' ) } );
+User.findAll( { order : [s.literal( 'email = ' + s.escape( 'test@sequelizejs.com' ) )] } );
+User.findAll( { order : [['id', ';DELETE YOLO INJECTIONS']] } );
+User.findAll( { include : [User], order : [[User, 'id', ';DELETE YOLO INJECTIONS']] } );
+User.findAll( { include : [User], order : [['id', 'ASC NULLS LAST'], [User, 'id', 'DESC NULLS FIRST']] } );
+User.findAll( { include : [{ model : User, where : { title : 'DoDat' }, include : [{ model : User }] }] } );
+User.findAll( { attributes: ['username', 'data']});
+User.findAll( { attributes: {include: ['username', 'data']} });
+User.findAll( { attributes: [['username', 'user_name'], ['email', 'user_email']] });
+User.findAll( { attributes: [s.fn('count', Sequelize.col('*'))] });
+// currently suffering from flow union type bugs
+// User.findAll( { attributes: [[s.fn('count', Sequelize.col('*')), 'count']] });
+// User.findAll( { attributes: [[s.fn('count', Sequelize.col('*')), 'count']], group: ['sex'] });
+// User.findAll( { attributes: [s.cast(s.fn('count', Sequelize.col('*')), 'INTEGER')] });
+// User.findAll( { attributes: [[s.cast(s.fn('count', Sequelize.col('*')), 'INTEGER'), 'count']] });
+User.findAll( { where : s.fn('count', [0, 10]) } );
+User.findAll( { where: s.where(s.fn('lower', s.col('email')), s.fn('lower', 'TEST@SEQUELIZEJS.COM')) } );
+User.findAll( { subQuery: false, include : [User], order : [[User, User, 'numYears', 'c']] } );
+User.findAll( { rejectOnEmpty: true });
+
+
+User.findById( 'a string' );
+User.findByPk( 'a string' );
+
+User.findOne( { where : { username : 'foo' } } );
+User.findOne( { where : { id : 1 }, attributes : ['id', ['username', 'name']] } );
+User.findOne( { where : { id : 1 }, attributes : ['id'] } );
+User.findOne( { where : { username : 'foo' }, logging : function(  ) { } } );
+User.findOne( { limit : 10 } );
+User.findOne( { where : { title : 'homework' }, include : [User] } );
+User.findOne( { where : { name : 'environment' }, include : [{ model : User, as : 'PrivateDomain' }] } );
+User.findOne( { where : { username : 'foo' }, transaction : t } ).then( ( p ) => p );
+User.findOne( { include : [User] } );
+User.findOne( { include : [{ model : User, as : 'Work' }] } );
+User.findOne( { where : { name : 'worker' }, include : [{ model : User, as : 'ToDo' }] } );
+User.findOne( { include : [{ model : User, as : 'ToDo' }, { model : User, as : 'DoTo' }] } );
+User.findOne( { where : { name : 'worker' }, include : [User] } );
+User.findOne( { where : { name : 'Boris' }, include : [User, { model : User, as : 'Photos' }] } );
+User.findOne( { where : { username : 'someone' }, include : [User] } );
+User.findOne( { where : { username : 'barfooz' }, raw : true } );
+User.findOne( { where : s.fn('count', []) } );
+User.findOne( { where: s.where(s.fn('lower', s.col('email')), s.fn('lower', 'TEST@SEQUELIZEJS.COM')) } );
+/* NOTE https://github.com/DefinitelyTyped/DefinitelyTyped/pull/5590
+User.findOne( { updatedAt : { ne : null } } );
+ */
+User.find( { where : { intVal : { gt : 5 } } } );
+User.find( { where : { intVal : { lte : 5 } } } );
+
+User.count();
+User.count( { transaction : t } );
+User.count().then( function( c ) { c.toFixed(); } );
+User.count( { where : ["username LIKE '%us%'"] } );
+User.count( { include : [{ model : User, required : false }] } );
+User.count( { distinct : true, include : [{ model : User, required : false }] } );
+User.count( { attributes : ['data'], group : ['data'] } );
+User.count( { where : { access_level : { gt : 5 } } } );
+
+User.findAndCountAll( { offset : 5, limit : 1, include : [User, { model : User, as : 'a' }] } );
+
+User.max( 'age', { transaction : t } );
+User.max( 'age' );
+User.max( 'age', { logging : function(  ) { } } );
+
+User.min( 'age', { transaction : t } );
+User.min( 'age' );
+User.min( 'age', { logging : function(  ) { } } );
+
+User.sum( 'order' );
+User.sum( 'age', { where : { 'gender' : 'male' } } );
+User.sum( 'age', { logging : function(  ) { } } );
+
+User.build( { username : 'John Wayne' } ).save();
+User.build();
+User.build( { id : 1, T : [{ n : 'a' }, { id : 2 }], A : { id : 1, n : 'a', c : 'a' } }, { include : [User, Task] } );
+User.build( { id : 1, }, { include : [{ model : User, as : 'followers' }, { model : Task, as : 'categories' }] } );
+
+User.create();
+User.create( { createdAt : 1, updatedAt : 2 }, { silent : true } );
+User.create( {}, { returning : true } );
+User.create( { intVal : s.literal( 'CAST(1-2 AS' ) } );
+User.create( { secretValue : s.fn( 'upper', 'sequelize' ) } );
+User.create( { myvals : [1, 2, 3, 4], mystr : ['One', 'Two', 'Three', 'Four'] } );
+User.create( { name : 'Fluffy Bunny', smth : 'else' }, { logging : function(  ) {} } );
+User.create( {}, { fields : [] } );
+User.create( { name : 'Yolo Bear', email : 'yolo@bear.com' }, { fields : ['name'] } );
+User.create( { title : 'Chair', User : { first_name : 'Mick', last_name : 'Broadstone' } }, { include : [User] } );
+User.create( { title : 'Chair', creator : { first_name : 'Matt', last_name : 'Hansen' } }, { include : [User] } );
+User.create( { id : 1, title : 'e', Tags : [{ id : 1, name : 'c' }, { id : 2, name : 'd' }] }, { include : [User] } );
+User.create( { id : 'My own ID!' } ).then( ( i ) => i.isNewRecord );
+
+let findOrRetVal: Promise<[Model<Object>, boolean]>;
+findOrRetVal = User.findOrInitialize( { where : { username : 'foo' } } );
+findOrRetVal = User.findOrInitialize( { where : { username : 'foo' }, transaction : t } );
+findOrRetVal = User.findOrInitialize( { where : { username : 'foo' }, defaults : { foo : 'asd' }, transaction : t } );
+findOrRetVal = User.findOrInitialize( { where : { username : 'foo' }, defaults : { foo : 'asd' }, paranoid : false } );
+
+findOrRetVal = User.findOrCreate( { where : { a : 'b' }, defaults : { json : { a : { b : 'c' }, d : [1, 2, 3] } } } );
+findOrRetVal = User.findOrCreate( { where : { a : 'b' }, defaults : { json : 'a', data : 'b' } } );
+/* NOTE https://github.com/DefinitelyTyped/DefinitelyTyped/pull/5590
+User.findOrCreate( { where : { a : 'b' }, transaction : t, lock : t.LOCK.UPDATE } );
+ */
+findOrRetVal = User.findOrCreate( { where : { a : 'b' }, logging : function(  ) { } } );
+findOrRetVal = User.findOrCreate( { where : { username : 'Username' }, defaults : { data : 'some data' }, transaction : t } );
+findOrRetVal = User.findOrCreate( { where : { objectId : 'asdasdasd' }, defaults : { username : 'gottlieb' } } );
+findOrRetVal = User.findOrCreate( { where : { id : null }, defaults : { name : Math.random().toString() } } );
+findOrRetVal = User.findOrCreate( { where : { email : 'unique.email.@d.com', companyId : Math.floor( Math.random() * 5 ) } } );
+findOrRetVal = User.findOrCreate( { where : { objectId : 1 }, defaults : { bool : false } } );
+
+User.upsert( { id : 42, username : 'doe', foo : s.fn( 'upper', 'mixedCase2' ) } );
+
+User.bulkCreate( [{ aNumber : 10 }, { aNumber : 12 }] ).then( ( i ) => i[0].isNewRecord );
+User.bulkCreate( [{ username : 'bar' }, { username : 'bar' }, { username : 'bar' }] );
+User.bulkCreate( [{}, {}], { validate : true, individualHooks : true } );
+User.bulkCreate( [{ style : 'ipa' }], { logging : function() { } } );
+User.bulkCreate( [{ a : 'b', c : 'd', e : 'f' }, { a : 'b', c : 'd', e : 'f' }], { fields : ['a', 'b'] } );
+User.bulkCreate( [{ name : 'foo', code : '123' }, { code : 'c' }, { name : 'bar', code : '1' }], { validate : true } );
+User.bulkCreate( [{ name : 'foo', code : '123' }, { code : '1234' }], { fields : ['code'], validate : true } );
+User.bulkCreate( [{ name : 'a', c : 'b' }, { name : 'e', c : 'f' }], { fields : ['e', 'f'], ignoreDuplicates : true } );
+
+User.truncate();
+User.truncate( { cascade : true } );
+User.truncate( { force : true } );
+User.truncate( { cascade: true, force : true } );
+
+User.destroy( { where : { client_id : 13 } } ).then( ( a ) => a.toFixed() );
+User.destroy( { force : true } );
+User.destroy( { where : {}, transaction : t } );
+User.destroy( { where : { access_level : { lt : 5 } } } );
+User.destroy( { truncate : true } );
+User.destroy( { where : {} } );
+
+User.restore( { where : { secretValue : '42' } } );
+
+User.update( { username : 'ruben' }, { where : {} } );
+User.update( { username : 'ruben' }, { where : { access_level : { lt : 5 } } } );
+User.update( { username : 'ruben' }, { where : { username : 'dan' } } );
+User.update( { username : 'bar' }, { where : { username : 'foo' }, transaction : t } );
+User.update( { username : 'Bill', secretValue : '43' }, { where : { secretValue : '42' }, fields : ['username'] } );
+User.update( { username : s.cast( '1', 'char' ) }, { where : { username : 'John' } } );
+User.update( { username : s.fn( 'upper', s.col( 'username' ) ) }, { where : { username : 'John' } } );
+User.update( { username : 'Bill' }, { where : { secretValue : '42' }, returning : true } );
+User.update( { secretValue : '43' }, { where : { username : 'Peter' }, limit : 1 } );
+User.update( { name : Math.random().toString() }, { where : { id : '1' } } );
+User.update( { a : { b : 10, c : 'd' } }, { where : { username : 'Jan' }, sideEffects : false } );
+User.update( { geometry : { type : 'Point', coordinates : [49.807222, -86.984722] } }, {
+  where : {
+    u : {
+      u : 'u',
+      geometry : { type : 'Point', coordinates : [49.807222, -86.984722] }
+    }
+  }
+} );
+User.update( {
+  geometry : {
+    type : 'Polygon',
+    coordinates : [[[100.0, 0.0], [102.0, 0.0], [102.0, 1.0], [100.0, 1.0], [100.0, 0.0]]]
+  }
+}, {
+  where : {
+    username : {
+      username : 'username',
+      geometry : { type : 'Point', coordinates : [49.807222, -86.984722] }
+    }
+  }
+} );
+
+User.unscoped().find( { where : { username : 'bob' } } );
+User.unscoped().count();
+
+//
+//  Model Statics
+// ~~~~~~~~~~~~~~~
+//
+
+User.sequelize.query;
+User.QueryInterface.addColumn;
+User.QueryGenerator.selectQuery;
+user.sequelize.query;
+
+//
+//  Query Interface
+// ~~~~~~~~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/query-interface.test.js
+//
+
+let queryInterface = s.getQueryInterface();
+
+queryInterface.dropAllTables();
+queryInterface.showAllTables( { logging : function() { } } );
+queryInterface.createTable( 'table', { name : Sequelize.STRING }, { logging : function() { } } );
+queryInterface.createTable( 'skipme', { name : Sequelize.STRING } );
+queryInterface.dropAllTables( { skip : ['skipme'] } );
+queryInterface.dropTable( 'Group', { logging : function() { } } );
+queryInterface.addIndex( 'Group', { fields: ['username', 'isAdmin'] } );
+queryInterface.showIndex( 'Group', { logging : function() { } } );
+queryInterface.removeIndex( 'Group', ['username', 'isAdmin'], { logging : function() { } } );
+queryInterface.showIndex( 'Group' );
+queryInterface.createTable( 'table', { name : { type : Sequelize.STRING } }, { schema : 'schema' } );
+queryInterface.showIndex( { schema : 'schema', tableName : 'table' }, { logging : function() {} } );
+queryInterface.describeTable( '_Users', { logging : function() {} } );
+queryInterface.createTable( 's', { table_id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true } } );
+queryInterface.createTable( 'SomeTable', { someEnum : Sequelize.ENUM( 'value1', 'value2', 'value3' ) } );
+queryInterface.createTable( 'SomeTable', { someEnum : { type : Sequelize.ENUM, values : ['b1', 'b2', 'b3'] } } );
+queryInterface.createTable( 't', { someEnum : { type : Sequelize.ENUM, values : ['c1', 'c2', 'c3'], field : 'd' } } );
+queryInterface.createTable( 'User', { name : { type : Sequelize.STRING } }, { schema : 'hero' } );
+queryInterface.rawSelect( 'User', { schema : 'hero', logging : function() {} }, 'name' );
+queryInterface.renameColumn( '_Users', 'username', 'pseudo', { logging : function() {} } );
+queryInterface.renameColumn( { schema : 'archive', tableName : 'Users' }, 'username', 'pseudo' );
+queryInterface.renameColumn( '_Users', 'username', 'pseudo' );
+queryInterface.createTable( { tableName : 'y', schema : 'a' },
+  { id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true }, currency : Sequelize.INTEGER } );
+queryInterface.changeColumn( { tableName : 'a', schema : 'b' }, 'c', { type : Sequelize.FLOAT },
+  { logging : () => s } );
+queryInterface.createTable( 'users', { id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true } } );
+queryInterface.createTable( 'level', { id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true } } );
+queryInterface.addColumn( 'users', 'someEnum', Sequelize.ENUM( 'value1', 'value2', 'value3' ) );
+queryInterface.addColumn( 'users', 'so', { type : Sequelize.ENUM, values : ['value1', 'value2', 'value3'] } );
+queryInterface.createTable( 'hosts', {
+  id : {
+    type : Sequelize.INTEGER,
+    primaryKey : true,
+    autoIncrement : true
+  },
+  admin : {
+    type : Sequelize.INTEGER,
+    references : {
+      model : User,
+      key : 'id'
+    }
+  },
+  operator : {
+    type : Sequelize.INTEGER,
+    references : {
+      model : User,
+      key : 'id'
+    },
+    onUpdate : 'cascade'
+  },
+  owner : {
+    type : Sequelize.INTEGER,
+    references : {
+      model : User,
+      key : 'id'
+    },
+    onUpdate : 'cascade',
+    onDelete : 'set null'
+  }
+} );
+//
+//
+//  Query Types
+// ~~~~~~~~~~~~~
+//
+
+s.getDialect();
+s.validate();
+s.authenticate();
+s.isDefined( '' );
+s.model( 'pp' );
+s.query( '', { raw : true } );
+s.query( '' );
+s.query( '' ).then( function( res ) {} );
+s.query( { query : 'select ? as foo, ? as bar', values : [1, 2] }, { raw : true, replacements : [1, 2] } );
+s.query( '', { raw : true, nest : false } );
+s.query( 'select ? as foo, ? as bar', { type : sequelize.QueryTypes.SELECT, replacements : [1, 2] } );
+s.query( { query : 'select ? as foo, ? as bar', values : [1, 2] }, { type : s.QueryTypes.SELECT } );
+s.query( 'select :one as foo, :two as bar', { raw : true, replacements : { one : 1, two : 2 } } );
+s.transaction().then( function( t ) { s.set( { foo : 'bar' }, { transaction : t } ); } );
+s.define( 'foo', { bar : Sequelize.STRING }, { collate : 'utf8_bin' } );
+s.define( 'Foto', { name : Sequelize.STRING }, { tableName : 'photos' } );
+s.databaseVersion().then( function( version ) { } );
+
+//
+//  Sequelize
+// ~~~~~~~~~~~
+//
+
+new Sequelize( 'db', 'user', 'pw', { logging : false } );
+new Sequelize( 'db', 'user', 'pass', {
+  dialect : '',
+  port : 99999,
+  pool : {}
+} );
+new Sequelize( '' ).query( '', { type : s.QueryTypes.FOREIGNKEYS, logging : function() {} } );
+new Sequelize( 'sqlite://test.sqlite' );
+new Sequelize( 'wat', 'trololo', 'wow', { port : 99999 } );
+new Sequelize( 'localhost', 'wtf', 'lol', { port : 99999 } );
+new Sequelize( 'sequelize', null, null, {
+  replication : {
+    read : {
+      host : 'localhost',
+      username : 'omg',
+      password : 'lol'
+    }
+  }
+} );
+new Sequelize( {
+  database: 'db',
+  username: 'user',
+  password: 'pass',
+  retry: {
+    match: ['failed'],
+    max: 3
+  },
+  typeValidation: true
+} );
+new Sequelize( {
+  database: 'db',
+  username: 'user',
+  password: 'pass',
+  retry: {
+    match: [/failed/],
+    max: 3
+  },
+  typeValidation: true
+} );
+
+new Sequelize({
+  operatorsAliases: false,
+});
+
+new Sequelize({
+  operatorsAliases: {
+    $and: Sequelize.Op.and,
+    customAlias: Sequelize.Op.or,
+  },
+});
+
+s.model( 'Project' );
+s.models['Project'];
+s.define( 'Project', {
+  name : Sequelize.STRING
+} );
+
+let testModel = s.define( 'User', {
+  username : Sequelize.STRING,
+  secretValue : Sequelize.STRING,
+  data : Sequelize.STRING,
+  intVal : Sequelize.INTEGER,
+  theDate : Sequelize.DATE,
+  aBool : Sequelize.BOOLEAN
+} );
+testModel = s.define( 'FrozenUser', {}, { freezeTableName : true } );
+s.define( 'UserWithClassAndInstanceMethods', {}, {
+  classMethods : { doSmth : function() { return 1; } },
+  instanceMethods : { makeItSo : function() { return 2; } }
+} );
+s.define( 'UserCol', {
+  id : {
+    type : Sequelize.STRING,
+    defaultValue : 'User',
+    primaryKey : true
+  }
+} );
+s.define( 'UserWithTwoAutoIncrements', {
+  userid : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true },
+  userscore : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true }
+} );
+s.define( 'Foo', {
+  field : Sequelize.INTEGER
+}, {
+  validate : {
+    field : function() {}
+  }
+} );
+let UserTable = s.define( 'UserCol', {
+  aNumber : Sequelize.INTEGER,
+  createdAt : {
+    type : Sequelize.DATE,
+    defaultValue : new Date()
+  },
+  updatedAt : {
+    type : Sequelize.DATE,
+    defaultValue : new Date()
+  }
+}, { timestamps : true } );
+
+s.define( 'UserCol', {
+  aNumber : Sequelize.INTEGER
+}, {
+  timestamps : true,
+  updatedAt : 'updatedOn',
+  createdAt : 'dateCreated',
+  deletedAt : 'deletedAtThisTime',
+  paranoid : true
+} );
+s.define( 'UpdatingUser', {
+  name : Sequelize.STRING
+}, {
+  timestamps : true,
+  updatedAt : false,
+  createdAt : false,
+  deletedAt : 'deletedAtThisTime',
+  paranoid : true
+} );
+s.define( 'TaskBuild', {
+  title : {
+    type : Sequelize.STRING( 50 ),
+    allowNull : false,
+    defaultValue : ''
+  }
+}, {
+  setterMethods : {
+    title : function() { }
+  }
+} );
+s.define( 'UserCol', {
+  aNumber : Sequelize.INTEGER
+}, {
+  paranoid : true,
+  underscored : true
+} );
+
+s.define( 'UserWithUniqueUsername', {
+  username : { type : Sequelize.STRING, unique : { name : 'user_and_email', msg : 'User and email must be unique' } },
+  email : { type : Sequelize.STRING, unique : 'user_and_email' }
+} );
+
+s.define( 'UserWithUniqueUsername', {
+  user_id : { type : Sequelize.INTEGER },
+  email : { type : Sequelize.STRING }
+}, {
+  indexes : [
+    {
+      name : 'user_and_email_index',
+      unique : true,
+      method : 'BTREE',
+      fields : ['user_id', { attribute : 'email', collate : 'en_US', order : 'DESC', length : 5 }],
+      where : {
+        user_id : { $not: null }
+      }
+    },
+    {
+      fields: ['data'],
+      using: 'gin',
+      operator: 'jsonb_path_ops'
+    }
+  ]
+} );
+
+s.define( 'TaskBuild', {
+  title : { type : Sequelize.STRING, defaultValue : 'a task!' },
+  foo : { type : Sequelize.INTEGER, defaultValue : 2 },
+  bar : { type : Sequelize.DATE },
+  foobar : { type : Sequelize.TEXT, defaultValue : 'asd' },
+  flag : { type : Sequelize.BOOLEAN, defaultValue : false }
+} );
+s.define( 'ProductWithSettersAndGetters1', {
+  price : {
+    type : Sequelize.INTEGER,
+    get : function() {
+      return 'answer = ' + this.getDataValue( 'price' );
+    },
+    set : function( v: number ) {
+      return this.setDataValue( 'price', v + 42 );
+    }
+  }
+} );
+s.define( 'ProductWithSettersAndGetters2', {
+  priceInCents : Sequelize.INTEGER
+}, {
+  setterMethods : {
+    price : function( value ) {
+      this.dataValues.priceInCents = value * 100;
+    }
+  },
+  getterMethods : {
+    price : function() {
+      return '$' + (this.getDataValue( 'priceInCents' ) / 100);
+    },
+
+    priceInCents : function() {
+      return this.dataValues.priceInCents;
+    }
+  }
+} );
+
+s.define( 'post', {
+  title : Sequelize.STRING,
+  authorId : { type : Sequelize.INTEGER, references : testModel, referencesKey : 'id' }
+} );
+s.define( 'post', {
+  title : Sequelize.STRING,
+  authorId : { type : Sequelize.INTEGER, references : { model : testModel, key : 'id' } }
+} );
+
+s.define( 'User', {
+  username : Sequelize.STRING,
+  geometry : Sequelize.GEOMETRY( 'POINT' )
+} );
+
+s.define( 'ScopeMe', {
+  username : Sequelize.STRING,
+  email : Sequelize.STRING,
+  access_level : Sequelize.INTEGER,
+  other_value : Sequelize.INTEGER,
+  parent_id : Sequelize.INTEGER
+}, {
+  defaultScope : {
+    where : {
+      access_level : {
+        gte : 5
+      }
+    }
+  },
+  scopes : {
+    isTony : {
+      where : {
+        username : 'tony'
+      }
+    },
+  }
+} );
+s.define( 'company', {
+  active : Sequelize.BOOLEAN
+}, {
+  defaultScope : {
+    where : { active : true }
+  },
+  scopes : {
+    notActive : {
+      where : {
+        active : false
+      }
+    },
+    reversed : {
+      order : [['id', 'DESC']]
+    }
+  }
+} );
+s.define( 'profile', {
+  active : Sequelize.BOOLEAN
+}, {
+  defaultScope : {
+    where : { active : true }
+  },
+  scopes : {
+    notActive : {
+      where : {
+        active : false
+      }
+    },
+  }
+} );
+
+s.define( 'ScopeMe', {
+  username : Sequelize.STRING,
+  email : Sequelize.STRING,
+  access_level : Sequelize.INTEGER,
+  other_value : Sequelize.INTEGER
+}, {
+  defaultScope : {
+    where : {
+      access_level : {
+        gte : 5
+      }
+    }
+  },
+  scopes : {
+    lowAccess : {
+      where : {
+        access_level : {
+          lte : 5
+        }
+      }
+    },
+    withOrder : {
+      order : 'username'
+    }
+  }
+} );
+
+// Generic find options
+interface ChairAttributes {
+  id: number;
+  color: string;
+  legs: number;
+}
+declare class ChairInstance extends Model<ChairAttributes> {}
+
+const Chair = s.define('chair', {});
+
+Chair.findAll({
+  where: {
+    color: 'blue',
+    legs: { $in: [3, 4] },
+  },
+});
+
+// https://github.com/facebook/flow/issues/3258 :(
+// Chair.findAll({
+//   where: {
+//     color: 'blue',
+//     legs: { [Sequelize.Op.in]: [3, 4] },
+//   },
+// });
+
+// If you want to use a property that isn't explicitly on the model's Attributes
+// use the find-function's generic type parameter.
+Chair.findAll({
+  where: {
+    customProperty: 123,
+  }
+});
+Chair.findAll({
+  where: {
+    customProperty1: 123,
+    customProperty2: 456,
+  }
+});
+
+s.define( 'ScopeMe', {
+  username : Sequelize.STRING,
+  email : Sequelize.STRING,
+  access_level : Sequelize.INTEGER,
+  other_value : Sequelize.INTEGER
+}, {
+  defaultScope : {
+    where : {
+      access_level : {
+        gte : 5
+      }
+    }
+  },
+  scopes : {
+    lowAccess : {
+      where : {
+        access_level : {
+          lte : 5
+        }
+      }
+    }
+  }
+} );
+
+s.define( 'user', {
+  id : {
+    type : Sequelize.INTEGER,
+    allowNull : false,
+    primaryKey : true,
+    autoIncrement : true,
+    field : 'userId'
+  },
+  name : {
+    type : Sequelize.STRING,
+    field : 'full_name'
+  },
+  taskCount : {
+    type : Sequelize.INTEGER,
+    field : 'task_count',
+    defaultValue : 0,
+    allowNull : false
+  }
+}, {
+  tableName : 'users',
+  timestamps : false
+} );
+s.define( 'task', {
+  id : {
+    type : Sequelize.INTEGER,
+    allowNull : false,
+    primaryKey : true,
+    autoIncrement : true,
+    field : 'taskId'
+  },
+  title : {
+    type : Sequelize.STRING,
+    field : 'name'
+  }
+}, {
+  tableName : 'tasks',
+  timestamps : false
+} );
+s.define( 'comment', {
+  id : {
+    type : Sequelize.INTEGER,
+    allowNull : false,
+    primaryKey : true,
+    autoIncrement : true,
+    field : 'commentId'
+  },
+  text : {
+    type : Sequelize.STRING,
+    field : 'comment_text'
+  },
+  notes : {
+    type : Sequelize.STRING,
+    field : 'notes'
+  }
+}, {
+  tableName : 'comments',
+  timestamps : false
+} );
+s.define( 'test', {
+  id : {
+    type : Sequelize.INTEGER,
+    field : 'test_id',
+    autoIncrement : true,
+    primaryKey : true,
+    validate : {
+      min : 1
+    }
+  },
+  title : {
+    allowNull : false,
+    type : Sequelize.STRING( 255 ),
+    field : 'test_title'
+  }
+}, {
+  timestamps : true,
+  underscored : true,
+  freezeTableName : true
+} );
+s.define( 'testBooeanVersionOption', {
+  version : {
+    type : Sequelize.INTEGER,
+  }
+}, {
+  version: true
+} );
+s.define( 'testStringVersionOption', {
+  nameOfOptimisticLockColumn : {
+    type : Sequelize.INTEGER,
+  }
+}, {
+  version: "nameOfOptimisticLockColumn"
+} );
+s.define( 'User', {
+  deletedAt : {
+    type : Sequelize.DATE,
+    field : 'deleted_at'
+  }
+}, {
+  timestamps : true,
+  paranoid : true
+} );
+
+s.define( 'TriggerTest', {
+  id : {
+    type : Sequelize.INTEGER,
+    field : 'test_id',
+    autoIncrement : true,
+    primaryKey : true,
+    validate : {
+      min : 1
+    }
+  },
+  title : {
+    allowNull : false,
+    type : Sequelize.STRING( 255 ),
+    field : 'test_title'
+  }
+}, {
+  timestamps : false,
+  underscored : true,
+  hasTrigger : true
+} );
+
+s.define('DefineOptionsIndexesTest', {
+  id: {
+    type: Sequelize.INTEGER,
+    autoIncrement: true,
+    primaryKey: true,
+    validate: {
+      min: 1
+    }
+  },
+  email: {
+    allowNull: false,
+    type: Sequelize.STRING(255),
+    set: function (val) {
+      if (typeof val === "string") {
+        val = val.toLowerCase();
+      } else {
+        throw new Error("email must be a string");
+      }
+      this.setDataValue("email", val);
+    }
+  }
+}, {
+  timestamps: false,
+  indexes: [
+    {
+      name: "DefineOptionsIndexesTest_lower_email",
+      unique: true,
+      fields: [
+        Sequelize.fn("LOWER", Sequelize.col("email"))
+      ]
+    }
+  ]
+} );
+
+//
+//  Transaction
+// ~~~~~~~~~~~~~
+//
+//  https://github.com/sequelize/sequelize/blob/v3.4.1/test/integration/transaction.test.js
+//
+
+s.transaction().then( function( t ) {
+
+  t.commit();
+  t.rollback();
+
+  User.find( {
+    where : {
+      username : 'John'
+    },
+    include : [User],
+    lock : t.LOCK.UPDATE,
+    transaction : t
+  } );
+  User.find( {
+    where : {
+      username : 'John'
+    },
+    include : [User],
+    lock : {
+      level : t.LOCK.UPDATE,
+      of : User
+    },
+    transaction : t
+  } );
+  User.update( {
+    active : true
+  }, {
+    where : {
+      active : false
+    },
+    transaction : t
+  } );
+  User.find( {
+    where : {
+      username : 'jan'
+    },
+    lock : t.LOCK.NO_KEY_UPDATE,
+    transaction : t
+  } );
+  User.find( {
+    where : {
+      username : 'jan'
+    },
+    lock : t.LOCK.KEY_SHARE,
+    transaction : t
+  } );
+
+} );
+
+s.transaction({
+  isolationLevel: s.Transaction.ISOLATION_LEVELS.READ_COMMITTED
+}).then(function(t2) {
+  return User.find({
+    where: {
+      username: 'jan'
+    },
+    lock: t2.LOCK.UPDATE,
+    transaction: t2
+  });
+});
+
+let autoCallback = (t: Transaction):Promise<string> => { return Promise.resolve('a') }
+let callbackValidator = (r:string) => {}
+s.transaction( autoCallback ).then( callbackValidator );
+s.transaction( { isolationLevel : 'SERIALIZABLE' }, autoCallback ).then( callbackValidator );
+s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.SERIALIZABLE }, autoCallback ).then( callbackValidator );
+s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.READ_COMMITTED }, autoCallback ).then( callbackValidator );
+
+// transaction types
+new Sequelize( '', { transactionType: 'DEFERRED' } );
+new Sequelize( '', { transactionType: Sequelize.Transaction.TYPES.DEFERRED} );
+new Sequelize( '', { transactionType: Sequelize.Transaction.TYPES.IMMEDIATE} );
+new Sequelize( '', { transactionType: Sequelize.Transaction.TYPES.EXCLUSIVE} );
+s.transaction( { type : 'DEFERRED' }, (t) => Promise.resolve() );
+s.transaction( { type : s.Transaction.TYPES.DEFERRED }, (t) => Promise.resolve() );
+s.transaction( { type : s.Transaction.TYPES.IMMEDIATE }, (t) => Promise.resolve() );
+s.transaction( { type : s.Transaction.TYPES.EXCLUSIVE }, (t) => Promise.resolve() );
+
+// promise transaction
+let asyncAutoCallback = async (t: Transaction):Promise<string> => 'a'
+s.transaction( asyncAutoCallback ).then( callbackValidator );
+
+// afterCommit hook
+s.transaction(async (t: Transaction): Promise<void> => {
+  t.afterCommit(async (t: Transaction): Promise<void> => {
+  });
+});
+
+// sync options types
+s.sync({
+  alter: true,
+  force: true,
+  hooks: false,
+  searchPath: 'some/path/',
+  schema: 'schema',
+  logging: () => {},
+  match: new RegExp('\d{4,}')
+});
diff --git a/definitions/npm/socket.io-client_v2.x.x/flow_v0.104.x-/socket.io-client_v2.x.x.js b/definitions/npm/socket.io-client_v2.x.x/flow_v0.104.x-v0.200.x/socket.io-client_v2.x.x.js
similarity index 100%
rename from definitions/npm/socket.io-client_v2.x.x/flow_v0.104.x-/socket.io-client_v2.x.x.js
rename to definitions/npm/socket.io-client_v2.x.x/flow_v0.104.x-v0.200.x/socket.io-client_v2.x.x.js
diff --git a/definitions/npm/socket.io-client_v2.x.x/flow_v0.201.x-/socket.io-client_v2.x.x.js b/definitions/npm/socket.io-client_v2.x.x/flow_v0.201.x-/socket.io-client_v2.x.x.js
new file mode 100644
index 0000000000..66dc4b6141
--- /dev/null
+++ b/definitions/npm/socket.io-client_v2.x.x/flow_v0.201.x-/socket.io-client_v2.x.x.js
@@ -0,0 +1,77 @@
+declare module "socket.io-client" {
+  declare type Callback = (...args: any[]) => void;
+
+  declare type ManagerOptions = $Shape<{
+    path: string,
+    reconnection: boolean,
+    reconnectionAttempts: number,
+    reconnectionDelay: number,
+    reconnectionDelayMax: number,
+    randomizationFactor: number,
+    timeout: number,
+    transports: ("polling" | "websocket")[],
+    transportOptions: { polling: { extraHeaders: { [string]:string, ... }, ... }, ... },
+    autoConnect: boolean,
+    query: { [string]: string, ... },
+    parser: any,
+    ...
+  }>;
+
+  declare type SocketOptions = $Shape<{ query: string, ... }>;
+
+  declare class Emitter<T> {
+    on(event: string, cb: Callback): T;
+    addEventListener(event: string, cb: Callback): T;
+    once(event: string, cb: Callback): T;
+    off(event: string, cb: Callback): T;
+    removeListener(event: string, cb: Callback): T;
+    removeAllListeners(event?: string): T;
+    removeEventListener(event: string, cb: Callback): T;
+    emit(event: string, payload: mixed): T;
+    listeners(event: string): Callback[];
+    hasListeners(event: string): boolean;
+  }
+
+  declare export class Manager extends Emitter<Manager> {
+    constructor(uri?: string, opts?: ManagerOptions): Manager;
+    opts: ManagerOptions;
+    reconnection(boolean): Manager;
+    reconnectionAttempts(number): Manager;
+    reconnectionDelay(number): Manager;
+    randomizationFactor(number): Manager;
+    reconnectionDelayMax(number): Manager;
+    timeout(number): Manager;
+    open(fn?: (err?: Error) => void): Manager;
+    connect(fn?: (err?: Error) => void): Manager;
+    socket(namespace: string, opts?: SocketOptions): Socket;
+  }
+
+  declare export class Socket extends Emitter<Socket> {
+    constructor(io: Manager, nsp: string, opts?: SocketOptions): Socket;
+    id: string;
+    open(): Socket;
+    connect(): Socket;
+    send(...args: any[]): Socket;
+    emit(event: string, ...args: any[]): Socket; // overrides Emitter#emit
+    close(): Socket;
+    disconnect(): Socket;
+    compress(boolean): Socket;
+    io: Manager;
+  }
+
+  // all of ManagerOptions with a few additions
+  declare type LookupOptions = $Shape<
+    {
+      forceNew: boolean,
+      "force new connection": true,
+      multiplex: boolean,
+      ...
+    } & ManagerOptions
+  >;
+
+  declare type Lookup = (uri?: string, opts?: LookupOptions) => Socket;
+
+  declare export var protocol: 4;
+  declare export var connect: Lookup;
+  declare export default Lookup
+}
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.104.x-/test_underscore-v1.js b/definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/test_underscore-v1.js
similarity index 100%
rename from definitions/npm/underscore_v1.x.x/flow_v0.104.x-/test_underscore-v1.js
rename to definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/test_underscore-v1.js
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.104.x-/test_underscore.js b/definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/test_underscore.js
similarity index 100%
rename from definitions/npm/underscore_v1.x.x/flow_v0.104.x-/test_underscore.js
rename to definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/test_underscore.js
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.104.x-/underscore_v1.x.x.js b/definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/underscore_v1.x.x.js
similarity index 100%
rename from definitions/npm/underscore_v1.x.x/flow_v0.104.x-/underscore_v1.x.x.js
rename to definitions/npm/underscore_v1.x.x/flow_v0.104.x-v0.200.x/underscore_v1.x.x.js
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore-v1.js b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore-v1.js
new file mode 100644
index 0000000000..fc9bd62bc4
--- /dev/null
+++ b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore-v1.js
@@ -0,0 +1,203 @@
+/** @flow */
+import _ from 'underscore';
+
+/**
+ * _.find
+ */
+_.find([1, 2, 3], x => x * 1 == 3);
+// $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);
+
+/**
+ * _.findWhere
+ */
+_.findWhere([{x: 1}, {y: 2}], {x: 2});
+// $FlowExpectedError number. This type is incompatible with function type.
+_.findWhere([{x: 1}, {y: 2}], 1);
+// XXX: It would be nice if Flow could catch this error.
+// See https://github.com/facebook/flow/issues/946
+_.findWhere([{x:1}, {x:2}, {x:3}], v => v.x == 3);
+
+
+/**
+ * _.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 these compatible with isEqual(a: any, b: any).
+// 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
+_.isEqual(1);
+
+
+/**
+ * _.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';
+
+/**
+ * _.bind
+ */
+_.bind(function(a,b){return this.x+a+b;}, {x: 1}, 2, 3);
+// $FlowExpectedError number. This type is incompatible with the expected param type of function type
+_.bind(123)
+
+/**
+ * _.bindAll
+ */
+_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, 'greet');
+_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, 'greet', 'toString');
+_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, ['greet'], 'toString');
+
+
+
+
+/**
+ * _.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
+
+
+/**
+ * _.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 `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
+_.zip([{x:1}], [{x:2,y:1}])[0][1].y
+
+
+
+/**
+ * _.any
+ */
+_.any([1, 2, 3], x => x == 1);
+// $FlowExpectedError number cannot be compared to string.
+_.any([1, 2, 3], x => x == 'a');
+
+
+/**
+ * _.find
+ */
+_.find([1, 2, 3], x => x == 1);
+// $FlowExpectedError number. This type is incompatible with function type.
+_.find([1, 2, 3], 1);
+// $FlowExpectedError Callable signature not found in object literal
+_.find([1, 2, 3], {val: 1});
+
+(_.findIndex([1, 2, 3], function(i) { return i % 2 == 0} ): number);
+// $FlowExpectedError number cannot be compared to string.
+(_.findIndex([1, 2, 3], function(i) { return i == '0'} ): number);
+
+(_.indexOf(['a', 'b', 'c'], function(e) { return e == 'b'}): number);
+
+(_.contains(['a', 'b', 'c'], 'b'): boolean);
+
+(_.map(['hello', 'world'], function(e) { return e.length }): Array<number>);
+(_.map({hello: 1, world: 2}, function(v, k) { return k.length }): Array<number>);
+// $FlowExpectedError This type is incompatible with string
+(_.map({hello: 1, world: 2}, function(v, k) { return k * 2 }): Array<number>);
+
+(_.mapObject({foo: 1, bar: 2}, function (v, k) {return (k.length + v).toString()}): {[key: string]: string, ...});
+// $FlowExpectedError This type is incompatible with number
+(_.mapObject({foo: 1, bar: 2}, function (v, k) {return (k.length + v).toString()}): number);
+
+(_.pluck([{name: 'bob'}, {name: 'jane'}], 'name'): Array<string>);
+(_.reduce([1, 2, 3], function(m, o) { return m + o }, 0): number);
+(_.all([2, 4, 5], function(i) { return i % 2 == 0 }): boolean);
+// $FlowExpectedError Property not found in Number
+(_.all([2, 4, 5], function(i) { return i.length }): boolean);
+(_.some([2, 4, 5], function(i) { return i % 2 == 0 }): boolean);
+(_.union(['a', 'b'], ['b']): Array<string>);
+(_.intersection(['a', 'b'], ['b']): Array<string>);
+(_.difference(['a', 'b'], ['b']): Array<string>);
+(_.first([1,2,3]): number);
+(_.first([1,2,3], 2): Array<number>);
+(_.last([1,2,3]): number);
+(_.last([1,2,3], 2): Array<number>);
+(_.sample([1,2,3]): number);
+(_.sortBy(['hello', 'world'], function(e) { return e.length }): Array<string>);
+(_.uniq([1,2,2]): Array<number>);
+(_.compact([1, null]): Array<number>);
+(_.select([1,2,3], function(e: number): boolean { return e % 2 == 0 }): Array<number>);
+(_.reject([1,2,3], function(e) { return e % 2 == 0 }): Array<number>);
+(_.without([1,2,3], 1, 2): Array<number>);
+(_.has({a: 1, b: 2}, 'b'): boolean);
+(_.isArray([1, 2]): boolean);
+(_.isArray(1): boolean);
+(_.pick({a: 1, b: 2}, 'a'): {[key: string]: number, ...});
+(_.omit({a: 1, b: 2}, 'a'): {[key: string]: number, ...});
+
+_.throttle(function(a) {a.length}, 10)('hello');
+_.debounce(function(a) {a.length}, 10)('hello');
+
+_.memoize(function(){})();
+_.partial(function (a, b) { return a + b }, 1)(2);
+_.delay(function(){}, 0);
+_.defer(function(){});
+
+(
+
+  _.compose(
+    function (name:string):string { return name + ', hello!'; },
+    function (user:Object):string { return user.name; }
+  ): (user: Object) => string
+
+);
+
+(_.partition([1,5,2,4], function(i: number) { return i<4 }): [Array<number>, Array<number>]);
+(_.partition({x: 'foo', y: 'bar'}, function(v: string, k: string) { return k === 'bar' }): [Array<string>, Array<string>]);
+
+(_.size([1,2]): number);
+(_.size({a: 1, b: 2}): number);
+
+_.template("a<%=b%>c")({b: "_"});
+// $FlowExpectedError `foo` property not found in Function
+_.template(321).foo;
+// $FlowExpectedError This type is incompatible with string
+_.template(321)({b: "_"});
+// $FlowExpectedError This type is incompatible with string
+_.template("a<%=b%>c")({b: 1});
+
+_.isObject({});
+_.isArguments(null);
+_.isFunction(() => {});
+_.isString('');
+_.isBoolean(true);
+_.isNumber(1);
+_.isFinite(1);
+_.isBoolean(1);
+_.isDate(new Date());
+_.isRegExp(/[a-z]/);
+_.isError(new Error('?'));
+_.isNaN(NaN);
+_.isNull(null);
+_.isUndefined(undefined);
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore.js b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore.js
new file mode 100644
index 0000000000..8efb25d157
--- /dev/null
+++ b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/test_underscore.js
@@ -0,0 +1,158 @@
+/** @flow */
+import _ from 'underscore';
+
+_.where([{title: "Cymbeline", author: "Shakespeare", year: 1611}, {title: "The Tempest", author: "Shakespeare", year: 1611}], {author: 'Shakespeare', year: 1611});
+
+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+
+_.indexBy([{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}], 'age');
+
+_.countBy([1, 2, 3, 4, 5], function(num) {
+	return num % 2 == 0 ? 'even': 'odd';
+});
+
+_.shuffle([1, 2, 3, 4, 5, 6]);
+
+_.unzip([['moe', 30, true], ['larry', 40, false], ['curly', 50, false]]);
+
+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+
+_.sortedIndex([10, 20, 30, 40, 50], 35);
+
+_.findLastIndex([{'id': 1, 'name': 'Bob', 'last': 'Brown'}, {'id': 2, 'name': 'Ted', 'last': 'White'}, {'id': 3, 'name': 'Frank', 'last': 'James'}, {'id': 4, 'name': 'Ted', 'last': 'Jones'}], {
+	name: 'Ted'
+});
+
+_.once(function () {});
+
+_.after(1, function () {});
+
+_.before(1, function () {});
+
+_.wrap(function (name) {return 'hello: ' + name;}, function(func) {return 'before, ' + func('moe') + ', after';});
+
+_.negate(Boolean);
+
+function Stooge(name) {
+	this.name = name;
+}
+Stooge.prototype.silly = true;
+_.allKeys(new Stooge('Moe'));
+
+_.invert({Moe: 'Moses', Larry: 'Louis', Curly: 'Jerome'});
+
+_.functions(_);
+
+_.extend({name: 'moe'}, {age: 50});
+
+/* starting with 1.8
+_.extendOwn({name: 'moe'}, {age: 50});
+_.assign({name: 'moe'}, {age: 50});
+*/
+
+_.defaults({flavor: 'chocolate'}, {flavor: 'vanilla', sprinkles: 'lots'});
+_.defaults({}, {flavor: 'chocolate'});
+_.defaults({flavor: 'chocolate'}, {sprinkles: 'lots'}, {foo: 'bar'}, {foo1: 'bar1'});
+_.defaults({flavor: 'chocolate'}, {flavor: 'vanilla'});
+_.defaults({zero: 0, one: 1, empty: '', nan: NaN, nothing: null}, {zero: 1, one: 10, twenty: 20, nothing: 'str'});
+_.defaults({zero: 0, one: 1, empty: '', nan: NaN, nothing: null}, {empty: 'full'}, {nan: 'nan'}, {word: 'word'}, {word: 'dog'});
+_.defaults(null, {a: 1});
+_.defaults(void 0, {a: 1});
+// $FlowExpectedError
+_.defaults({}, null, void 0, {a: 1});
+
+_.isMatch({name: 'moe', age: 32}, {age: 32});
+
+_.isElement(0);
+
+_.constant({name: 'moe'})();
+
+_.uniqueId('contact_');
+
+_.escape('Curly, Larry & Moe');
+
+_.unescape('Curly, Larry &amp; Moe');
+
+_.some(['a', true, 0]);
+_.any(['a', true, 0]);
+_.every(['a', true, 0]);
+_.all(['a', true, 0]);
+
+_.union([1, 2, 3], [2, 30, 1], [1, 40]);
+_([1, 2, 3]).union([2, 30, 1], [1, 40]);
+_.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
+// $FlowExpectedError
+_.union([1, 2, 3], 4)
+
+_.filter([1, 2, 3, 4, 5, 6], function(num: number): boolean { return num % 2 === 0; });
+_.filter([1, 2, 3, 4, 5, 6], function(num, index: number, as: number[]): boolean {
+  return num % 2 == 0 || index === 7 || as.length > 3;
+});
+_.filter({name: 'foo', a: 'bar'}, function (val, key, obj): boolean {
+  var testKey = key + 'foo';
+  var allKeys = _.keys(obj);
+  return val === 'foo';
+});
+var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}];
+_.filter(list, {a: 1});
+_.filter(list, {})
+_(list).filter({})
+
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v) => v.t === 'a');
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v, k) => k === 'a' && v.t === 'a');
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v, k, o) => k === 'a' && v.t === 'a' && o[k] === v);
+
+// $FlowExpectedError
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v) => v.s === 'a');
+// $FlowExpectedError
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v: { t: string, ... }, k: number) => (k === 1) && (v.t === 'a'));
+// $FlowExpectedError
+_.findKey({a: {t: 'a'}, b: {t: 'b'}}, (v, k, o: { t: string, ... }) => k === 'a' && v.t === 'a' && o.t === v);
+
+
+// $FlowExpectedError
+_.zip([{x:1}], [{x:2,y:1}])[0][2]
+// $FlowExpectedError array literal. Tuple arity mismatch.
+_.bindAll({msg: 'hi', greet: function(){ return this.msg;}}, ['greet', 'toString']);
+
+var identityIsString: string = _.identity('foo');
+// $FlowExpectedError
+var identityIsNotString: string = _.identity(42);
+
+var timesString: Array<string> = _.times(3, (i) => `str${i}`);
+var timesNumber: Array<number> = _.times(3, (i) => i + 1);
+// $FlowExpectedError
+var timesNumberError: Array<string> = _.times(3, (i) => i + 1);
+
+var toArrayString: Array<string> = _.toArray({foo: 'bar', baz: 'qux'});
+var toArrayNumber: Array<number> = _.toArray({foo: 4, bar: 2});
+// $FlowExpectedError
+var toArrayNumberError: Array<string> = _.toArray({foo: 4, baz: 2});
+
+var composed: (prop: { num: number, ... }) => number = _.compose(
+  (prop: { num: number, ... }) => prop.num
+);
+
+var composed2: (prop: { num: number, ... }) => string = _.compose(
+  (num: number) => num + '',
+  (prop: { num: number, ... }) => prop.num,
+);
+
+// $FlowExpectedError
+var composedFail: (prop: { num: number, ... }) => number = _.compose(
+  (num: number) => num + '',
+  (prop: { num: number, ... }) => prop.num,
+);
+
+// Wrapped
+
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v) => v.t === 'a');
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v, k) => k === 'a' && v.t === 'a');
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v, k, o) => k === 'a' && v.t === 'a' && o[k] === v);
+
+// $FlowExpectedError
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v) => v.s === 'a');
+// $FlowExpectedError
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v: { t: string, ... }, k: number) => (k === 1) && (v.t === 'a'));
+// $FlowExpectedError
+_({a: {t: 'a'}, b: {t: 'b'}}).findKey((v, k, o: { t: string, ... }) => k === 'a' && v.t === 'a' && o.t === v);
diff --git a/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/underscore_v1.x.x.js b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/underscore_v1.x.x.js
new file mode 100644
index 0000000000..ad37887788
--- /dev/null
+++ b/definitions/npm/underscore_v1.x.x/flow_v0.201.x-/underscore_v1.x.x.js
@@ -0,0 +1,699 @@
+// @flow
+/* eslint-disable */
+
+// type definitions for (some of) underscore
+
+type FnIteratee<T> = (t: T, index: number, array: Array<T>) => boolean;
+
+declare module "underscore" {
+  declare type UnaryFn<A, R> = (a: A) => R;
+  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>,
+      ...rest: Array<void>
+    ) => 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>,
+      ...rest: Array<void>
+    ) => UnaryFn<A, F>)
+    & (<A, B, C, D, E>(
+      de: UnaryFn<D, E>,
+      cd: UnaryFn<C, D>,
+      bc: UnaryFn<B, C>,
+      ab: UnaryFn<A, B>,
+      ...rest: Array<void>
+    ) => UnaryFn<A, E>)
+    & (<A, B, C, D>(cd: UnaryFn<C, D>, bc: UnaryFn<B, C>, ab: UnaryFn<A, B>, ...rest: Array<void>) => UnaryFn<A, D>)
+    & (<A, B, C>(bc: UnaryFn<B, C>, ab: UnaryFn<A, B>, ...rest: Array<void>) => UnaryFn<A, C>)
+    & (<A, B>(ab: UnaryFn<A, B>, ...rest: Array<void>) => UnaryFn<A, B>)
+
+  declare function $underscore$Extend<A: {...}>(a: A, ...rest: Array<void>): A;
+  declare function $underscore$Extend<A: {...}, B: {...}>(a: A, b: B, ...rest: Array<void>): A & B;
+  declare function $underscore$Extend<A: {...}, B: {...}, C: {...}>(a: A, b: B, c: C, ...rest: Array<void>): A & B & C;
+  declare function $underscore$Extend<A: {...}, B: {...}, C: {...}, D: {...}>(a: A, b: B, c: C, d: D, ...rest: Array<void>): A & B & C & D;
+  declare function $underscore$Extend<A: {...}, B: {...}, C: {...}, D: {...}, E: {...}>(a: A, b: B, c: C, d: D, e: E, ...rest: Array<void>): A & B & C & D & E;
+
+  declare function $underscore$ExtendParameterized<A: {...}>(...rest: Array<void>): A;
+  declare function $underscore$ExtendParameterized<A: {...}, B: {...}>(b: B, ...rest: Array<void>): A & B;
+  declare function $underscore$ExtendParameterized<A: {...}, B: {...}, C: {...}>(b: B, c: C, ...rest: Array<void>): A & B & C;
+  declare function $underscore$ExtendParameterized<A: {...}, B: {...}, C: {...}, D: {...}>(b: B, c: C, d: D, ...rest: Array<void>): A & B & C & D;
+  declare function $underscore$ExtendParameterized<A: {...}, B: {...}, C: {...}, D: {...}, E: {...}>(b: B, c: C, d: D, e: E, ...rest: Array<void>): A & B & C & D & E;
+
+
+  declare var compose: Compose;
+
+  // Handle underscore chainables things.
+  declare class UnderscoreWrappedList<T> {
+    // Chain
+    chain(): UnderscoreChainedList<T>;
+
+    // Handle Collections functions
+    each(iteratee: (element: T, index?: number, list?: Array<T>) => void): void;
+    each(iteratee: (val: mixed, key: mixed, list?: Object) => void): void;
+    map<U>(iteratee: (value: T, index: number, list: Array<T>) => U): Array<U>;
+    reduce<U>(iteratee: (memo: Object, value: T, index: number) => U, init: Object): Object;
+    reduce<U>(iteratee: (memo: Array<U>, value: T, index: number) => U, init: Array<U>): Array<U>;
+    reduce<U>(iteratee: (memo: U, value: T, index: number) => U, init: U): U;
+    reduceRight<U>(iteratee: (memo: Object, value: T, index: number) => U, init: Object): Object;
+    reduceRight<U>(iteratee: (memo: Array<U>, value: T, index: number) => U, init: Array<U>): Array<U>;
+    reduceRight<U>(iteratee: (memo: U, value: T, index: number) => U, init: U): U;
+    find(predicate: (value: T) => boolean): T;
+    filter(predicate: (value: ?T) => boolean): Array<T>;
+    where(properties: Object): Array<T>;
+    findWhere(properties: $Shape<T>): ?T;
+    reject(predicate: (value: T) => boolean, context?: mixed): Array<T>;
+    every(predicate: (value: T) => boolean, context?: mixed): boolean;
+    some(predicate: (value: T) => boolean, context?: mixed): boolean;
+    contains(value: T, fromIndex?: number): boolean;
+    invoke<U>(methodName: string, ...args: Array<any>): Array<U>;
+    pluck<U>(propertyName: string): Array<U>;
+    max<U>(iteratee?: (value: T) => number, context?: mixed): U;
+    min<U>(iteratee?: (value: T) => number, context?: mixed): U;
+    sortBy<U>(iteratee: (value: T) => number): Array<U>;
+    sortBy<U>(iteratee: string): Array<U>;
+    // TODO: UnderscoreWrapTheseObjects
+    groupBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    groupBy(iteratee: string, context?: mixed): { [key: any]: T, ... };
+    indexBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    indexBy(iteratee: string, context?: mixed): { [key: any]: T, ... };
+    countBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    shuffle(): Array<T>;
+    sample(n?: number): Array<T>;
+    toArray(): Array<T>;
+    size(): number;
+    partition(predicate: (value: T) => boolean): Array<Array<T>>;
+
+    // Handle Array function
+    first(): T;
+    first(n: number): Array<T>;
+    head(n?: number): Array<T>;
+    take(n?: number): Array<T>;
+    initial(n?: number): Array<T>;
+    last(n?: number): Array<T>;
+    rest(index?: number): Array<T>;
+    tail(index?: number): Array<T>;
+    drop(index?: number): Array<T>;
+    compact(): Array<T>;
+    flatten(shallow?: boolean): Array<T>;
+    without(...values: Array<any>): Array<T>;
+    union(...arrays: Array<any>): Array<T>;
+    intersection(...arrays: Array<any>): Array<T>;
+    difference(...others: Array<any>): Array<T>;
+    uniq(): Array<T>;
+    uniq(iteratee: FnIteratee<T>): Array<T>;
+    uniq(isSorted: boolean, iteratee?: FnIteratee<T>): Array<T>;
+    unique(): Array<T>;
+    unique(iteratee: FnIteratee<T>): Array<T>;
+    unique(isSorted: boolean, iteratee?: FnIteratee<T>): Array<T>;
+    zip(...arrays: Array<any>): Array<T>;
+    unzip(): Array<T>;
+    object(values?: Array<any>): Object;
+    indexOf(value: T, isSorted?: boolean): number;
+    lastIndexOf(value: T, iteratee?: Function, context?: mixed): number;
+    sortedIndex(value: T, iteratee?: Function, context?: mixed): number;
+    findIndex(predicate: (value: T) => boolean, context?: mixed): number;
+    findLastIndex(predicate: (value: T) => boolean, context?: mixed): number;
+    range(stop: number, step?: number): Array<number>;
+    range(): Array<number>;
+
+    // TODO _.propertyOf
+    // TODO _.matcher, _.matches
+    isEqual(b: Object): boolean;
+    isMatch(b: Object): boolean;
+    isEmpty(): boolean;
+    isElement(): boolean;
+    isArray(): boolean;
+    isObject(): boolean;
+    isArguments(): boolean;
+    isFunction(): boolean;
+    isString(): boolean;
+    isNumber(): boolean;
+    isFinite(): boolean;
+    isBoolean(): boolean;
+    isDate(): boolean;
+    isRegExp(): boolean;
+    isError(): boolean;
+    isNaN(): boolean;
+    isNull(): boolean;
+    isUndefined(): boolean;
+  }
+
+
+  // Handle underscore chainables things.
+  declare class UnderscoreChainedList<T> {
+    // End a Chain
+    value(): Array<T>;
+
+    // Handle Collections functions
+    each(iteratee: (element: T, index: number, list: Array<T>) => void): Array<T>;
+    each(iteratee: (val: mixed, key: mixed, list: Object) => void): Object;
+    map<U>(iteratee: (value: T, index: number, list: Array<T>) => U): UnderscoreChainedList<U>;
+    reduce<U>(iteratee: (memo: Object, value: T, index: number) => U, init: Object): UnderscoreChainedValue<Object>;
+    reduce<U>(iteratee: (memo: Array<U>, value: T, index: number) => U, init: Array<U>): UnderscoreChainedList<U>;
+    reduce<U>(iteratee: (memo: U, value: T, index: number) => U, init: U): UnderscoreChainedValue<U>;
+    reduceRight<U>(iteratee: (memo: Object, value: T, index: number) => U, init: Object): UnderscoreChainedValue<U>;
+    reduceRight<U>(iteratee: (memo: Array<U>, value: T, index: number) => U, init: Array<U>): UnderscoreChainedList<U>;
+    reduceRight<U>(iteratee: (memo: U, value: T, index: number) => U, init: U): UnderscoreChainedValue<U>;
+    find(predicate: (value: T) => boolean): UnderscoreChainedValue<T>;
+    filter(predicate: (value: T) => boolean): UnderscoreChainedList<T>;
+    where(properties: Object): UnderscoreChainedList<T>;
+    findWhere(properties: $Shape<T>): ?UnderscoreChainedValue<T>;
+    reject(predicate: (value: T) => boolean, context?: mixed): UnderscoreChainedList<T>;
+    every(predicate: (value: T) => boolean, context?: mixed): UnderscoreChainedValue<boolean>;
+    some(predicate: (value: T) => boolean, context?: mixed): UnderscoreChainedValue<boolean>;
+    contains(value: T, fromIndex?: number): UnderscoreChainedValue<boolean>;
+    invoke<U>(methodName: string, ...args: Array<any>): UnderscoreChainedList<U>;
+    pluck<U>(propertyName: string): UnderscoreChainedList<U>;
+    max<U>(iteratee?: (value: T) => number, context?: mixed): UnderscoreChainedValue<U>;
+    min<U>(iteratee?: (value: T) => number, context?: mixed): UnderscoreChainedValue<U>;
+    sortBy<U>(iteratee: (value: T) => number): UnderscoreChainedList<U>;
+    sortBy<U>(iteratee: string): UnderscoreChainedList<U>;
+    // TODO: UnderscoreWrapTheseObjects
+    groupBy<U>(iteratee: (value: T) => U, context?: mixed): UnderscoreChainedValue<{ [key: U]: T, ... }>;
+    groupBy(iteratee: string, context?: mixed): UnderscoreChainedValue<{ [key: any]: T, ... }>;
+    indexBy<U>(iteratee: (value: T) => U, context?: mixed): UnderscoreChainedValue<{ [key: U]: T, ... }>;
+    indexBy(iteratee: string, context?: mixed): UnderscoreChainedValue<{ [key: any]: T, ... }>;
+    countBy<U>(iteratee: (value: T) => U, context?: mixed): UnderscoreChainedValue<{ [key: U]: T, ... }>;
+    shuffle(): UnderscoreChainedList<T>;
+    sample(n?: number): UnderscoreChainedList<T>;
+    toArray(): UnderscoreChainedList<T>;
+    size(): UnderscoreChainedValue<number>;
+    partition(predicate: (value: T) => boolean): UnderscoreChainedList<Array<T>>;
+
+    // Handle Array function
+    first(n: number): UnderscoreChainedList<T>;
+    first(): UnderscoreChainedValue<T>;
+    head(n?: number): UnderscoreChainedList<T>;
+    take(n?: number): UnderscoreChainedList<T>;
+    initial(n?: number): UnderscoreChainedList<T>;
+    last(n?: number): UnderscoreChainedList<T>;
+    rest(index?: number): UnderscoreChainedList<T>;
+    tail(index?: number): UnderscoreChainedList<T>;
+    drop(index?: number): UnderscoreChainedList<T>;
+    compact(): UnderscoreChainedList<T>;
+    flatten(shallow?: boolean): UnderscoreChainedList<T>;
+    without(...values: Array<any>): UnderscoreChainedList<T>;
+    union(...arrays: Array<any>): UnderscoreChainedList<T>;
+    intersection(...arrays: Array<any>): UnderscoreChainedList<T>;
+    difference(...others: Array<any>): UnderscoreChainedList<T>;
+    uniq(): UnderscoreChainedList<T>;
+    uniq(iteratee: FnIteratee<T>): UnderscoreChainedList<T>;
+    uniq(isSorted: boolean, iteratee?: FnIteratee<T>): UnderscoreChainedList<T>;
+    unique(): UnderscoreChainedList<T>;
+    unique(iteratee: FnIteratee<T>): UnderscoreChainedList<T>;
+    unique(isSorted: boolean, iteratee?: FnIteratee<T>): UnderscoreChainedList<T>;
+    zip(...arrays: Array<any>): UnderscoreChainedList<T>;
+    unzip(): UnderscoreChainedList<T>;
+    object(values?: Array<any>): UnderscoreChainedValue<Object>;
+    indexOf(value: T, isSorted?: boolean): UnderscoreChainedValue<number>;
+    lastIndexOf(value: T, iteratee?: Function, context?: mixed): UnderscoreChainedValue<number>;
+    sortedIndex(value: T, iteratee?: Function, context?: mixed): UnderscoreChainedValue<number>;
+    findIndex(predicate: (value: T) => boolean, context?: mixed): UnderscoreChainedValue<number>;
+    findLastIndex(predicate: (value: T) => boolean, context?: mixed): UnderscoreChainedValue<number>;
+    range(stop: number, step?: number): UnderscoreChainedList<number>;
+    range(): UnderscoreChainedList<number>;
+
+    isEqual(b: Object): UnderscoreChainedValue<boolean>;
+    isMatch(b: Object): UnderscoreChainedValue<boolean>;
+    isEmpty(): UnderscoreChainedValue<boolean>;
+    isElement(): UnderscoreChainedValue<boolean>;
+    isArray(): UnderscoreChainedValue<boolean>;
+    isObject(): UnderscoreChainedValue<boolean>;
+    isArguments(): UnderscoreChainedValue<boolean>;
+    isFunction(): UnderscoreChainedValue<boolean>;
+    isString(): UnderscoreChainedValue<boolean>;
+    isNumber(): UnderscoreChainedValue<boolean>;
+    isFinite(): UnderscoreChainedValue<boolean>;
+    isBoolean(): UnderscoreChainedValue<boolean>;
+    isDate(): UnderscoreChainedValue<boolean>;
+    isRegExp(): UnderscoreChainedValue<boolean>;
+    isError(): UnderscoreChainedValue<boolean>;
+    isNaN(): UnderscoreChainedValue<boolean>;
+    isNull(): UnderscoreChainedValue<boolean>;
+    isUndefined(): UnderscoreChainedValue<boolean>;
+  }
+
+  declare class UnderscoreChainedValue<T> {
+    value(): T;
+  }
+
+  declare class UnderscoreWrappedValue<T> {
+    chain(): UnderscoreChainedValue<T>;
+
+    escape(): string;
+    // TODO: Probably move this to UnderscoreWrappedNumber or something
+    range(): Array<number>;
+    isEmpty(): boolean;
+  }
+
+  // Handle regular things.
+  declare class UnderscoreList {
+    // Handle chaining
+    chain<T>(a: Array<T>): UnderscoreChainedList<T>;
+    chain<T>(v: T): UnderscoreChainedValue<T>;
+
+    // Handle Collections functions
+
+    each<T>(o: { [key:string]: T, ... }, iteratee: (val: T, key: string)=>void): void;
+    each<T>(a: T[], iteratee: (val: T, key: string)=>void): void;
+    each(list: Object, iteratee: (val: mixed, key: mixed, list: Object) => void): void;
+    forEach<T>(o: { [key:string]: T, ... }, iteratee: (val: T, key: string)=>void): void;
+    forEach<T>(a: T[], iteratee: (val: T, key: string)=>void): void;
+
+    map<T, U>(a: T[], iteratee: (val: T, n: number)=>U): U[];
+    map<K, T, U>(a: { [key:K]: T, ... }, iteratee: (val: T, k: K)=>U): U[];
+    collect<T, U>(a: T[], iteratee: (val: T, n: number)=>U): U[];
+    collect<K, T, U>(a: { [key:K]: T, ... }, iteratee: (val: T, k: K)=>U): U[];
+
+    reduce<T, MemoT>(a: Array<T>, iterator: (m: MemoT, o: T)=>MemoT, initialMemo?: MemoT): MemoT;
+    inject<T, MemoT>(a: Array<T>, iterator: (m: MemoT, o: T)=>MemoT, initialMemo?: MemoT): MemoT;
+    foldl<T, MemoT>(a: Array<T>, iterator: (m: MemoT, o: T)=>MemoT, initialMemo?: MemoT): MemoT;
+
+    reduceRight<T, MemoT>(a: Array<T>, iterator: (m: MemoT, o: T)=>MemoT, initialMemo?: MemoT): MemoT;
+    foldr<T, MemoT>(a: Array<T>, iterator: (m: MemoT, o: T)=>MemoT, initialMemo?: MemoT): MemoT;
+
+    find<T>(list: T[], predicate: (val: T)=>boolean): ?T;
+    detect<T>(list: T[], predicate: (val: T)=>boolean): ?T;
+
+    filter<T>(o: { [key:string]: T, ... }, pred: (val: T, k: string, o: { [string]: T, ... })=>boolean): T[];
+    filter<T>(a: T[], pred: (val: T, k: number, a: T[])=>boolean): T[];
+    filter<T>(o: { [string]: T, ... }[], pred: { [string]: T, ... }): T[];
+    select<T>(o: { [key:string]: T, ... }, pred: (val: T, k: string, o: { [string]: T, ... })=>boolean): T[];
+    select<T>(a: T[], pred: (val: T, k: number, a: T[])=>boolean): T[];
+    select<T>(o: { [string]: T, ... }[], pred: { [string]: T, ... }): T[];
+    where<T>(list: Array<T>, properties: Object): Array<T>;
+    findWhere<T>(list: Array<T>, properties: { [key:string]: any, ... }): ?T;
+
+    reject<T>(o: { [key:string]: T, ... }, pred: (val: T, k: string)=>boolean): T[];
+    reject<T>(a: T[], pred: (val: T, k: string)=>boolean): T[];
+
+    every<T>(a: Array<T>, pred?: (val: T)=>boolean): boolean;
+    all<T>(a: Array<T>, pred?: (val: T)=>boolean): boolean;
+
+    some<T>(a: Array<T>, pred?: (val: T)=>boolean): boolean;
+    any<T>(a: Array<T>, pred?: (val: T)=>boolean): boolean;
+
+    contains<T>(list: T[], val: T, fromIndex?: number): boolean;
+    includes<T>(list: T[], val: T, fromIndex?: number): boolean;
+
+    invoke(list: Array<any>, methodName: string, ...args?: Array<any>): any;
+
+    pluck(a: Array<any>, propertyName: string): Array <any>;
+
+    max<T>(a: Array<T>|{ [key:any]: T, ... }): T;
+    min<T>(a: Array<T>|{ [key:any]: T, ... }): T;
+
+    sortBy<T>(a: T[], property: any): T[];
+    sortBy<T>(a: T[], iteratee: (val: T)=>any): T[];
+    groupBy<T>(a: Array<T>, iteratee: string | (val: T, index: number)=>any): { [key:string]: T[], ... };
+    indexBy<T>(a: Array<T>, iteratee: string | (val: T, index: number)=>any): { [key:string]: T[], ... };
+    countBy<T>(a: Array<T>, iteratee: (val: T, index: number)=>any): { [key:string]: T[], ... };
+    shuffle<T>(list: ?Array<T>): Array<T>;
+    sample<T>(a: T[]): T;
+
+    toArray<T>(a: Iterable<T>|{ [key:any]: T, ... }): Array<T>;
+
+    size(o: Object): number;
+    size(o: Array<any>): number;
+
+    partition<T>(o: { [key:string]: T, ... }, pred: (val: T, k: string)=>boolean): [T[], T[]];
+    partition<T>(o: Array<T>, pred: (val: T)=>boolean): [T[], T[]];
+
+    // Handle Array function
+
+    first<T>(a: Array<T>, n: number): Array<T>;
+    first<T>(a: Array<T>): T;
+    head<T>(a: Array<T>, n: number): Array<T>;
+    head<T>(a: Array<T>): T;
+    take<T>(a: Array<T>, n: number): Array<T>;
+    take<T>(a: Array<T>): T;
+
+    initial<T>(a: Array<T>, n?: number): Array<T>;
+
+    last<T>(a: Array<T>, n: number): Array<T>;
+    last<T>(a: Array<T>): T;
+
+    rest<T>(a: Array<T>, index?: number): Array<T>;
+    tail<T>(a: Array<T>, index?: number): Array<T>;
+    drop<T>(a: Array<T>, index?: number): Array<T>;
+
+    compact<T>(a: Array<?T>): T[];
+
+    flatten<S>(a: S[][]): S[];
+
+    without<T>(a: T[], ...values: T[]): T[];
+
+    union<T>(...arrays: Array<Array<T>>): Array<T>;
+    intersection<T>(...arrays: Array<Array<T>>): Array<T>;
+
+    difference<T>(array: Array<T>, ...others: Array<Array<T>>): Array<T>;
+
+    uniq<T>(a: T[]): T[];
+    uniq<T>(list: Array<T>, iteratee: Function): Array<T>;
+    uniq<T>(list: Array<T>, isSorted: boolean, iteratee?: Function): Array<T>;
+    unique<T>(a: T[]): T[];
+    unique<T>(list: Array<T>, iteratee: Function): Array<T>;
+    unique<T>(list: Array<T>, isSorted: boolean, iteratee?: Function): Array<T>;
+
+    zip<S, T>(a1: S[], a2: T[]): Array<[S, T]>;
+    unzip(array: Array<Array<any>>): Array<Array<any>>;
+
+    object<T>(a: Array<[string, T]>): { [key:string]: T, ... };
+    object<T>(list: Array<string>, values?: Array<T>): { [key: string]: T, ... };
+
+    indexOf<T>(list: T[], val: T, isSorted?: boolean): number;
+    lastIndexOf<T>(array: Array<T>, value: T, fromIndex?: number): number;
+    sortedIndex<T>(list: Array<T>, value: T, iteratee?: (value: T) => mixed, context?: any): number;
+    findIndex<T>(list: T[], predicate: (val: T)=>boolean): number;
+    findLastIndex<T>(array: Array<T>, predicate: any, context?: any): number;
+    range(a: number, b: number): Array<number>;
+
+    isEqual(object: Object, b: Object): boolean;
+    isMatch(object: Object, b: Object): boolean;
+    isEmpty(object: Object): boolean;
+    isElement(object: any): boolean;
+    isArray(value: any): boolean;
+    isObject(value: any): boolean;
+    isArguments(object: any): boolean;
+    isFunction(object: any): boolean;
+    isString(object: any): boolean;
+    isNumber(object: any): boolean;
+    isFinite(object: any): boolean;
+    isBoolean(object: any): boolean;
+    isDate(object: any): boolean;
+    isRegExp(object: any): boolean;
+    isError(object: any): boolean;
+    isNaN(object: any): boolean;
+    isNull(object: any): boolean;
+    isUndefined(object: any): boolean;
+  }
+
+  declare class UnderscoreFunctions {
+    bind(func: Function, object: Object, ...arguments: Array<any>): Function;
+    bindAll(object: ?Object, ...methodNames: Array<string | [string]>): Object;
+    partial(func: Function, ...arguments: Array<any>): Function;
+    memoize(func: Function, hashFunction?: Function): Function;
+    delay(func: Function, wait: number, ...arguments: Array<any>): void;
+    defer(func: Function, ...arguments: Array<any>): void;
+    throttle(func: Function, wait: number, options?: {
+      leading: boolean,
+      trailing: boolean,
+      ...
+    }): Function;
+    debounce(func: Function, wait: number, immediate?: boolean): Function;
+    once(func: Function): Function;
+    after(count: number, func: Function): Function;
+    before(count: number, func: Function): Function;
+    wrap(func: Function, wrapper: Function): Function;
+    negate(predicate: (...args: any) => boolean): Function;
+    compose: Compose;
+
+    isEqual(object: any, b: any): boolean;
+    isMatch(object: Object, b: Object): boolean;
+    isEmpty(object: Object): boolean;
+    isElement(object: Object): boolean;
+    isArray(value: any): boolean;
+    isObject(value: any): boolean;
+    isArguments(object: any): boolean;
+    isFunction(object: any): boolean;
+    isString(object: any): boolean;
+    isNumber(object: any): boolean;
+    isFinite(object: any): boolean;
+    isBoolean(object: any): boolean;
+    isDate(object: any): boolean;
+    isRegExp(object: any): boolean;
+    isError(object: any): boolean;
+    isNaN(object: any): boolean;
+    isNull(object: any): boolean;
+    isUndefined(object: any): boolean;
+  }
+
+  declare class UnderscoreObject {
+    keys<K, V>(object: { [keys: K]: V, ... }): Array<K>;
+    allKeys<K, V>(object: { [keys: K]: V, ... }): Array<K>;
+    values<K, V>(object: { [keys: K]: V, ... }): Array<V>;
+    mapObject(
+      object: Object,
+      iteratee: (val: any, key: string) => mixed,
+      context?: mixed
+    ): Object;
+    pairs<K, V>(object: { [keys: K]: V, ... }): Array<[K, V]>;
+    invert<K, V>(object: { [keys: K]: V, ... }): { [keys: V]: K, ... };
+    // TODO: _.create
+    functions(object: Object): Array<string>;
+    findKey<K, V>(object: { [keys: K]: V, ... }, predicate: (V, K, { [keys: K]: V, ... }) => boolean, context?: mixed): ?string;
+    extend: typeof $underscore$Extend;
+    extendOwn: typeof $underscore$Extend;
+    pick<K, V>(object: { [keys: K]: V, ... }, predicate?: K): { [keys: K]: V, ... };
+    omit<K, V>(object: { [keys: K]: V, ... }, predicate?: K): { [keys: K]: V, ... };
+    defaults(defaults: ?Object, ...mores?: Array<Object>): Object;
+    clone<O: {...}>(object: O): O;
+    tap<O>(object: O): O;
+    has(object: Object, key: string): boolean;
+    property<K: string, V>(key: K): (obj: { [key: K]: V, ... }) => V;
+    // TODO _.propertyOf
+    // TODO _.matcher, _.matches
+    isEqual(object: Object, b: Object): boolean;
+    isMatch(object: Object, b: Object): boolean;
+    isEmpty(object: Object): boolean;
+    isElement(object: any): boolean;
+    isArray(value: any): boolean;
+    isObject(value: any): boolean;
+    isArguments(object: any): boolean;
+    isFunction(object: any): boolean;
+    isString(object: any): boolean;
+    isNumber(object: any): boolean;
+    isFinite(object: any): boolean;
+    isBoolean(object: any): boolean;
+    isDate(object: any): boolean;
+    isRegExp(object: any): boolean;
+    isError(object: any): boolean;
+    isNaN(object: any): boolean;
+    isNull(object: any): boolean;
+    isUndefined(object: any): boolean;
+  }
+
+  declare class UnderscoreChainedObject<WrappedObj: {...}> {
+    value(): WrappedObj;
+    keys(): UnderscoreChainedList<$Keys<WrappedObj>>;
+    allKeys(): UnderscoreChainedList<$Keys<WrappedObj>>;
+    // This call necessarily loses precision since we treat chained lists generics of a single type.
+    values(): UnderscoreChainedList<any>;
+
+    mapObject<Ret, NewObj: $ObjMap<WrappedObj, <V>(v: V) => Ret>>(
+      iteratee: Function,
+      context?: mixed
+    ): UnderscoreChainedObject<NewObj>;
+    map<T>(mapFn: (v: any, k: $Keys<WrappedObj>, obj: WrappedObj) => T): UnderscoreChainedList<T>;
+    pairs(): UnderscoreChainedList<[any, any]>;
+    invert(): UnderscoreChainedObject<WrappedObj>;
+    // TODO: _.create
+    functions(): UnderscoreChainedList<string>;
+    findKey(predicate: ($Values<WrappedObj>, $Keys<WrappedObj>, WrappedObj) => boolean, context?: mixed): UnderscoreChainedValue<?$Keys<WrappedObj>>;
+    // TODO: Reimplement these when you can get them to return UnderscoreChainedObject
+    // extend: ExtendParameterized<{[key: K]: V}>;
+    // extendOwn: ExtendParameterized<{[key: K]: V}>>;
+    pick(...rest: Array<string | Array<string>>): UnderscoreChainedObject<WrappedObj>;
+    pick(predicate: (v: any, k: any, object: WrappedObj) => boolean): UnderscoreChainedObject<WrappedObj>;
+    omit(...rest: Array<string | Array<string>>): UnderscoreChainedObject<WrappedObj>;
+    omit(predicate: (v: any, k: any, object: WrappedObj) => boolean): UnderscoreChainedObject<WrappedObj>;
+    defaults(more: $Shape<WrappedObj>): UnderscoreChainedObject<WrappedObj>;
+    clone(): UnderscoreChainedObject<WrappedObj>;
+    tap(): UnderscoreChainedObject<WrappedObj>;
+    has(key: string): UnderscoreChainedValue<boolean>;
+    // TODO _.propertyOf
+    // TODO _.matcher, _.matches
+    isEqual(b: Object): UnderscoreChainedValue<boolean>;
+    isMatch(b: Object): UnderscoreChainedValue<boolean>;
+    isEmpty(): UnderscoreChainedValue<boolean>;
+    isElement(): UnderscoreChainedValue<boolean>;
+    isArray(): UnderscoreChainedValue<boolean>;
+    isObject(): UnderscoreChainedValue<boolean>;
+    isArguments(): UnderscoreChainedValue<boolean>;
+    isFunction(): UnderscoreChainedValue<boolean>;
+    isString(): UnderscoreChainedValue<boolean>;
+    isNumber(): UnderscoreChainedValue<boolean>;
+    isFinite(): UnderscoreChainedValue<boolean>;
+    isBoolean(): UnderscoreChainedValue<boolean>;
+    isDate(): UnderscoreChainedValue<boolean>;
+    isRegExp(): UnderscoreChainedValue<boolean>;
+    isError(): UnderscoreChainedValue<boolean>;
+    isNaN(): UnderscoreChainedValue<boolean>;
+    isNull(): UnderscoreChainedValue<boolean>;
+    isUndefined(): UnderscoreChainedValue<boolean>;
+  }
+
+  declare class UnderscoreWrappedObject<WrappedObj: {...}> {
+    chain(): UnderscoreChainedObject<WrappedObj>;
+
+    map<R>(fn: (v: any, k: $Keys<WrappedObj>) => R): Array<R>;
+    filter(fn: (v: any, k: $Keys<WrappedObj>, obj: any) => boolean): Array<any>;
+    keys(): Array<$Keys<WrappedObj>>;
+    allKeys(): Array<$Keys<WrappedObj>>;
+    values(): Array<any>;
+    mapObject<Ret, NewObj: $ObjMap<WrappedObj, <V>(v: V) => Ret>>(
+      iteratee: Function,
+      context?: mixed
+    ): NewObj;
+    pairs<K, V>(): Array<[K, V]>;
+    invert<K, V>(): { [keys: V]: K, ... };
+    // TODO: _.create
+    functions(): Array<string>;
+    find(predicate: (v: any, k: $Keys<WrappedObj>, obj: WrappedObj) => boolean): ?any;
+    findKey(predicate: ($Values<WrappedObj>, $Keys<WrappedObj>, WrappedObj) => boolean, context?: mixed): ?$Keys<WrappedObj>;
+    extend: typeof $underscore$ExtendParameterized;
+    extendOwn: typeof $underscore$ExtendParameterized;
+    // TODO make these actually remove properties
+    pick(...rest: Array<string | Array<string>>): WrappedObj;
+    pick(predicate: (v: any, k: $Keys<WrappedObj>, object: WrappedObj) => boolean): WrappedObj;
+    omit(...rest: Array<string | Array<string>>): WrappedObj;
+    omit(predicate: (v: any, k: $Keys<WrappedObj>, object: WrappedObj) => boolean): WrappedObj;
+    defaults(more: $Shape<WrappedObj>): WrappedObj;
+    clone(): WrappedObj;
+    tap(): WrappedObj;
+    has(key: string): boolean;
+    // TODO _.propertyOf
+    // TODO _.matcher, _.matches
+    isEqual(b: Object): boolean;
+    isMatch(b: Object): boolean;
+    isEmpty(): boolean;
+    isElement(): boolean;
+    isArray(): boolean;
+    isObject(): boolean;
+    isArguments(): boolean;
+    isFunction(): boolean;
+    isString(): boolean;
+    isNumber(): boolean;
+    isFinite(): boolean;
+    isBoolean(): boolean;
+    isDate(): boolean;
+    isRegExp(): boolean;
+    isError(): boolean;
+    isNaN(): boolean;
+    isNull(): boolean;
+    isUndefined(): boolean;
+  }
+
+  declare class UnderscoreUtility {
+    noConflict(): Underscore;
+    identity<U>(value: U): U;
+    constant<U>(value: U): () => U;
+    noop(): void;
+    times<T>(n: number, iteratee: (index: number) => T, context?: mixed): Array<T>;
+    random(min: number, max: number): number;
+    // TODO: Is this right?
+    mixin(object: Object): Underscore & Object;
+    // TODO: _.iteratee
+    uniqueId(prefix?: string): string;
+    escape(string: string): string;
+    unescape(string: string): string;
+    // TODO: _.result
+    now(): number;
+    template(templateText: string): (values: { [key: string]: string, ... }) => string;
+  }
+
+  declare class UnderscoreWrappedList<T> {
+    chain(): UnderscoreChainedList<T>;
+
+    // Handle Collections functions
+    each(iteratee: (element: T, index: number, list: Array<T>) => void): Array<T>;
+    each(iteratee: (val: mixed, key: mixed, list: Object) => void): Object;
+    map<U>(iteratee: (value: T, index: number, list: Array<T>) => U): Array<U>;
+    reduce<U>(iteratee: (memo: Object, value: T, index?: number) => U, init: Object): Object;
+    reduce<U>(iteratee: (memo: Array<U>, value: T, index?: number) => U, init: Array<U>): Array<U>;
+    reduce<U>(iteratee: (memo: U, value: T, index?: number) => U, init: U): U;
+    reduceRight<U>(iteratee: (memo: Object, value: T, index?: number) => U, init: Object): U;
+    reduceRight<U>(iteratee: (memo: Array<U>, value: T, index?: number) => U, init: Array<U>): Array<U>;
+    reduceRight<U>(iteratee: (memo: U, value: T, index?: number) => U, init: U): U;
+    find(predicate: (value: T) => boolean): ?T;
+    filter(predicate: (value: T) => boolean): Array<T>;
+    filter(predicate: { [string]: T, ... }): Array<T>;
+    where(properties: Object): Array<T>;
+    findWhere(properties: $Shape<T>): ?T;
+    reject(predicate: (value: T) => boolean, context?: mixed): Array<T>;
+    every(predicate: (value: T) => boolean, context?: mixed): boolean;
+    some(predicate: (value: T) => boolean, context?: mixed): boolean;
+    contains(value: T, fromIndex?: number): boolean;
+    invoke<U>(methodName: string, ...args: Array<any>): Array<U>;
+    pluck<U>(propertyName: string): Array<U>;
+    max<U>(iteratee?: (value: T) => number, context?: mixed): U;
+    min<U>(iteratee?: (value: T) => number, context?: mixed): U;
+    sortBy<U>(iteratee: (value: T) => number): Array<U>;
+    sortBy<U>(iteratee: string): Array<U>;
+    // TODO: UnderscoreWrapTheseObjects
+    groupBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    groupBy(iteratee: string, context?: mixed): { [key: any]: T, ... };
+    indexBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    indexBy(iteratee: string, context?: mixed): { [key: any]: T, ... };
+    countBy<U>(iteratee: (value: T) => U, context?: mixed): { [key: U]: T, ... };
+    shuffle(): Array<T>;
+    sample(n?: number): Array<T>;
+    toArray(): Array<T>;
+    size(): number;
+    partition(predicate: (value: T) => boolean): Array<Array<T>>;
+
+    // Handle Array function
+    first(): T;
+    first(n: number): Array<T>;
+    head(n?: number): Array<T>;
+    take(n?: number): Array<T>;
+    initial(n?: number): Array<T>;
+    last(n?: number): Array<T>;
+    rest(index?: number): Array<T>;
+    tail(index?: number): Array<T>;
+    drop(index?: number): Array<T>;
+    compact(): Array<T>;
+    flatten(shallow?: boolean): Array<T>;
+    without(...values: Array<any>): Array<T>;
+    union(...arrays: Array<any>): Array<T>;
+    intersection(...arrays: Array<any>): Array<T>;
+    difference(...others: Array<any>): Array<T>;
+    uniq(): Array<T>;
+    uniq(iteratee: Function): Array<T>;
+    uniq(isSorted: boolean, iteratee?: Function): Array<T>;
+    unique(): Array<T>;
+    unique(iteratee: Function): Array<T>;
+    unique(isSorted: boolean, iteratee?: Function): Array<T>;
+    zip(...arrays: Array<any>): Array<T>;
+    unzip(): Array<T>;
+    object(values?: Array<any>): Object;
+    indexOf(value: T, isSorted?: boolean): number;
+    lastIndexOf(value: T, iteratee?: Function, context?: mixed): number;
+    sortedIndex(value: T, iteratee?: Function, context?: mixed): number;
+    findIndex(predicate: (value: T) => boolean, context?: mixed): number;
+    findLastIndex(predicate: (value: T) => boolean, context?: mixed): number;
+    range(stop: number, step?: number): Array<number>;
+    range(): Array<number>;
+    isEmpty(): boolean;
+    isEqual(other: Array<T>): boolean;
+  }
+
+  // Have to use a type with [[call]] instead of function type because otherwise this will cause us to lose type
+  // information. see: https://github.com/facebook/flow/issues/3781
+  declare type WrappedExports = { [[call]]:
+    // A type that can be an object or an array (usually 'any') should have both return types.
+    & (<AnyType: {...} & []>(arg: AnyType) => UnderscoreWrappedObject<AnyType> & UnderscoreWrappedList<AnyType>)
+    // It's important that UnderscoreWrappedObject, UnderscoreWrappedList takes precedence over UnderscoreWrappedValue
+    & (<WrappedObj: {...}>(arg: WrappedObj) => UnderscoreWrappedObject<WrappedObj>)
+    & (<T>(arg: Array<T>) => UnderscoreWrappedList<T>)
+    & (<T>(arg: [T]) => UnderscoreWrappedList<T>)
+    & (<T>(arg: T) => UnderscoreWrappedValue<T>), ... }
+
+  declare type Underscore =
+    & UnderscoreList
+    & UnderscoreFunctions
+    & UnderscoreObject
+    & UnderscoreUtility
+    & WrappedExports;
+
+  declare module.exports: Underscore;
+}
diff --git a/definitions/npm/xterm_v3.x.x/flow_v0.104.x-/test_xterm_v3.x.x.js b/definitions/npm/xterm_v3.x.x/flow_v0.104.x-v0.200.x/test_xterm_v3.x.x.js
similarity index 100%
rename from definitions/npm/xterm_v3.x.x/flow_v0.104.x-/test_xterm_v3.x.x.js
rename to definitions/npm/xterm_v3.x.x/flow_v0.104.x-v0.200.x/test_xterm_v3.x.x.js
diff --git a/definitions/npm/xterm_v3.x.x/flow_v0.104.x-/xterm_v3.x.x.js b/definitions/npm/xterm_v3.x.x/flow_v0.104.x-v0.200.x/xterm_v3.x.x.js
similarity index 100%
rename from definitions/npm/xterm_v3.x.x/flow_v0.104.x-/xterm_v3.x.x.js
rename to definitions/npm/xterm_v3.x.x/flow_v0.104.x-v0.200.x/xterm_v3.x.x.js
diff --git a/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/test_xterm_v3.x.x.js b/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/test_xterm_v3.x.x.js
new file mode 100644
index 0000000000..66fb3507f5
--- /dev/null
+++ b/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/test_xterm_v3.x.x.js
@@ -0,0 +1,241 @@
+import { Terminal } from "xterm";
+
+// $FlowExpectedError (Options should be an object)
+new Terminal("{}");
+new Terminal({});
+
+// $FlowExpectedError (Can't pass invalid option)
+new Terminal({ col: 1 });
+new Terminal({ cols: 1 });
+
+// $FlowExpectedError (Options must use proper type)
+new Terminal({ col: 1 });
+new Terminal({ cols: 1 });
+
+// None of these should throw an error
+new Terminal();
+new Terminal({});
+new Terminal({ cols: 1, rows: 1 });
+new Terminal({
+  cols: 1,
+  cursorBlink: true,
+  cursorStyle: "block",
+  disableStdin: false,
+  rows: 1,
+  scrollback: 10,
+  tabStopWidth: 2
+});
+
+// $FlowExpectedError (Can't use undefined static methods)
+Terminal.applyAddOn({});
+Terminal.applyAddon({});
+
+let terminal = new Terminal();
+
+// $FlowExpectedError (terminal.element should be an HTMLElement)
+(terminal.element: string);
+(terminal.element: HTMLElement);
+
+// $FlowExpectedError (terminal.textarea should be an HTMLTextAreaElement)
+(terminal.textarea: number);
+(terminal.textarea: HTMLTextAreaElement);
+
+// $FlowExpectedError (Can't use undefined instance method)
+terminal.fokus();
+terminal.focus();
+
+// $FlowExpectedError (Instance methods should typecheck parameters)
+terminal.write({ foo: "bar" });
+terminal.write("foobar");
+
+// None of should throw an error (Mostly copied from the .d.ts test file)
+terminal.blur();
+terminal.focus();
+terminal.destroy();
+terminal.clear();
+terminal.refresh(0, 1);
+terminal.reset();
+terminal.resize(1, 1);
+terminal.write("foo");
+terminal.writeln("foo");
+terminal.on("blur", () => {});
+terminal.on("focus", () => {});
+terminal.on("linefeed", () => {});
+terminal.on("selection", () => {});
+terminal.on("data", () => {});
+terminal.on("data", (data: string) => console.log(data));
+terminal.on("key", () => {});
+terminal.on("key", (key: string) => console.log(key));
+terminal.on("key", (key: string, event: KeyboardEvent) =>
+  console.log(key, event)
+);
+terminal.on("keydown", () => {});
+terminal.on("keydown", (event: KeyboardEvent) => console.log(event));
+terminal.on("keypress", () => {});
+terminal.on("keypress", (event: KeyboardEvent) => console.log(event));
+terminal.on("refresh", () => {});
+terminal.on("refresh", (data: {
+  start: number,
+  end: number,
+  ...
+}) =>
+  console.log(data)
+);
+terminal.on("resize", () => {});
+terminal.on("resize", (data: {
+  cols: number,
+  rows: number,
+  ...
+}) =>
+  console.log(data)
+);
+terminal.on("scroll", () => {});
+terminal.on("scroll", (ydisp: number) => console.log(ydisp));
+terminal.on("title", () => {});
+terminal.on("title", (title: string) => console.log(title));
+terminal.off("blur", () => {});
+terminal.off("focus", () => {});
+terminal.off("linefeed", () => {});
+terminal.off("selection", () => {});
+terminal.off("data", () => {});
+terminal.off("data", (data: string) => console.log(data));
+terminal.off("key", () => {});
+terminal.off("key", (key: string) => console.log(key));
+terminal.off("key", (key: string, event: KeyboardEvent) =>
+  console.log(key, event)
+);
+terminal.off("keydown", () => {});
+terminal.off("keydown", (event: KeyboardEvent) => console.log(event));
+terminal.off("keypress", () => {});
+terminal.off("keypress", (event: KeyboardEvent) => console.log(event));
+terminal.off("refresh", () => {});
+terminal.off(
+  "refresh",
+  (data: {
+    element: HTMLElement,
+    start: number,
+    end: number,
+    ...
+  }) =>
+    console.log(data)
+);
+terminal.off("resize", () => {});
+terminal.off(
+  "resize",
+  (data: {
+    terminal: Terminal,
+    cols: number,
+    rows: number,
+    ...
+  }) =>
+    console.log(data)
+);
+terminal.off("scroll", () => {});
+terminal.off("scroll", (ydisp: number) => console.log(ydisp));
+terminal.off("title", () => {});
+terminal.off("title", (title: string) => console.log(title));
+let e: ?HTMLElement;
+e && terminal.open(e);
+terminal.attachCustomKeyEventHandler((e: KeyboardEvent) => true);
+terminal.attachCustomKeyEventHandler((e: KeyboardEvent) => false);
+const r01: string = terminal.getOption("cursorStyle");
+const r02: string = terminal.getOption("termName");
+const r03: boolean = terminal.getOption("cancelEvents");
+const r04: boolean = terminal.getOption("convertEol");
+const r05: boolean = terminal.getOption("cursorBlink");
+const r06: boolean = terminal.getOption("debug");
+const r07: boolean = terminal.getOption("disableStdin");
+const r08: boolean = terminal.getOption("popOnBell");
+const r09: boolean = terminal.getOption("screenKeys");
+const r10: boolean = terminal.getOption("useFlowControl");
+const r11: boolean = terminal.getOption("visualBell");
+const r12: string[] = terminal.getOption("colors");
+const r13: number = terminal.getOption("cols");
+const r14: number = terminal.getOption("rows");
+const r15: number = terminal.getOption("tabStopWidth");
+const r16: number = terminal.getOption("scrollback");
+const r18: (data: string) => void = terminal.getOption("handler");
+const r19: string = terminal.getOption("bellSound");
+const r20: string = terminal.getOption("bellStyle");
+const r21: boolean = terminal.getOption("enableBold");
+const r22: number = terminal.getOption("letterSpacing");
+const r23: boolean = terminal.getOption("macOptionIsMeta");
+const r24: string = terminal.getOption("fontWeight");
+const r25: string = terminal.getOption("fontWeightBold");
+const r26: boolean = terminal.getOption("allowTransparency");
+const r27: boolean = terminal.getOption("rightClickSelectsWord");
+terminal.setOption("cursorStyle", "bar");
+terminal.setOption("cursorStyle", "block");
+terminal.setOption("cursorStyle", "underline");
+terminal.setOption("termName", "foo");
+terminal.setOption("cancelEvents", true);
+terminal.setOption("convertEol", true);
+terminal.setOption("cursorBlink", true);
+terminal.setOption("debug", true);
+terminal.setOption("disableStdin", true);
+terminal.setOption("enableBold", true);
+terminal.setOption("fontWeight", "normal");
+terminal.setOption("fontWeight", "bold");
+terminal.setOption("fontWeightBold", "normal");
+terminal.setOption("fontWeightBold", "bold");
+terminal.setOption("popOnBell", true);
+terminal.setOption("screenKeys", true);
+terminal.setOption("useFlowControl", true);
+terminal.setOption("allowTransparency", true);
+terminal.setOption("visualBell", true);
+let colorsArr: Array<string> = ["a", "b"];
+terminal.setOption("colors", colorsArr);
+terminal.setOption("letterSpacing", 1);
+terminal.setOption("cols", 1);
+terminal.setOption("rows", 1);
+terminal.setOption("tabStopWidth", 1);
+terminal.setOption("scrollback", 1);
+terminal.setOption("handler", (data: string): void => console.log(data));
+terminal.setOption("bellSound", "foo");
+terminal.setOption("bellStyle", "none");
+terminal.setOption("bellStyle", "sound");
+terminal.setOption("fontSize", 1);
+terminal.setOption("lineHeight", 1);
+terminal.setOption("fontFamily", "foo");
+terminal.setOption("theme", { background: "#ff0000" });
+terminal.setOption("macOptionIsMeta", true);
+terminal.setOption("rightClickSelectsWord", false);
+terminal.scrollLines(-1);
+terminal.scrollLines(1);
+terminal.scrollLines(-1);
+terminal.scrollLines(1);
+terminal.scrollToTop();
+terminal.scrollToBottom();
+const r1: boolean = terminal.hasSelection();
+const r2: string = terminal.getSelection();
+terminal.clearSelection();
+terminal.selectAll();
+
+terminal.registerLinkMatcher(/foo/, () => {});
+terminal.registerLinkMatcher(new RegExp("foo"), () => {});
+terminal.registerLinkMatcher(/foo/, () => {}, {});
+terminal.registerLinkMatcher(
+  /foo/,
+  (event: MouseEvent, uri: string) => {
+    console.log(event, uri);
+    return void 0;
+  },
+  {}
+);
+terminal.registerLinkMatcher(/foo/, () => {}, {});
+terminal.registerLinkMatcher(/foo/, () => {}, {});
+terminal.registerLinkMatcher(/foo/, () => {}, {
+  matchIndex: 1
+});
+terminal.registerLinkMatcher(/foo/, () => {}, {
+  matchIndex: 1,
+  priority: 1,
+  validationCallback: (uri: string, callback: (isValid: boolean) => void) => {
+    console.log(uri, callback);
+  },
+  tooltipCallback: (e: MouseEvent, uri: string) => {
+    console.log(e, uri);
+  },
+  leaveCallback: () => {}
+});
+terminal.deregisterLinkMatcher(1);
diff --git a/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/xterm_v3.x.x.js b/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/xterm_v3.x.x.js
new file mode 100644
index 0000000000..0541ac3bac
--- /dev/null
+++ b/definitions/npm/xterm_v3.x.x/flow_v0.201.x-/xterm_v3.x.x.js
@@ -0,0 +1,266 @@
+declare module "xterm" {
+  declare export type FontWeight =
+    | "normal"
+    | "bold"
+    | "100"
+    | "200"
+    | "300"
+    | "400"
+    | "500"
+    | "600"
+    | "700"
+    | "800"
+    | "900";
+
+  declare export type Theme = $Shape<{
+    foreground: string,
+    background: string,
+    cursor: string,
+    cursorAccent: string,
+    selection: string,
+    black: string,
+    red: string,
+    green: string,
+    yellow: string,
+    blue: string,
+    magenta: string,
+    cyan: string,
+    white: string,
+    brightBlack: string,
+    brightRed: string,
+    brightGreen: string,
+    brightYellow: string,
+    brightBlue: string,
+    brightMagenta: string,
+    brightCyan: string,
+    brightWhite: string,
+    ...
+  }>;
+
+  declare export type TerminalOptions = $Shape<{
+    allowTransparency: boolean,
+    bellSound: string,
+    bellStyle: "none" | "sound",
+    cols: number,
+    cursorBlink: boolean,
+    cursorStyle: "block" | "underline" | "bar",
+    disableStdin: boolean,
+    enableBold: boolean,
+    fontSize: number,
+    fontFamily: string,
+    fontWeight: FontWeight,
+    fontWeightBold: FontWeight,
+    letterSpacing: number,
+    lineHeight: number,
+    macOptionIsMeta: boolean,
+    rightClickSelectsWord: boolean,
+    rows: number,
+    screenReaderMode: boolean,
+    scrollback: number,
+    tabStopWidth: number,
+    theme: Theme,
+    ...
+  }>;
+
+  declare export type LinkMatcherOptions = $Shape<{
+    matchIndex: number,
+    validationCallback: (
+      uri: string,
+      callback: (isValid: boolean) => void
+    ) => void,
+    tooltipCallback: (event: MouseEvent, uri: string) => boolean | void,
+    leaveCallback: (event: MouseEvent, uri: string) => boolean | void,
+    priority: number,
+    willLinkActivate: (event: MouseEvent, uri: string) => boolean,
+    ...
+  }>;
+
+  declare export type Disposable = {|
+    dispose(): void
+  |};
+
+  declare export type Marker = {|
+    ...Disposable,
+    +id: number,
+    +isDisposed: boolean,
+    +line: number
+  |};
+
+  declare export type LocalizableStrings = {|
+    blankLine: string,
+    promptLabel: string,
+    tooMuchOutput: string
+  |};
+
+  declare export class Terminal {
+    element: HTMLElement;
+    textarea: HTMLTextAreaElement;
+    rows: number;
+    cols: number;
+    markers: Marker[];
+    static strings: LocalizableStrings;
+    constructor(options?: TerminalOptions): Terminal;
+    blur(): void;
+    focus(): void;
+    on(
+      type: "blur" | "focus" | "linefeed" | "selection",
+      listener: () => void
+    ): void;
+    on(type: "data", listener: (...args: any[]) => void): void;
+    on(
+      type: "key",
+      listener: (key?: string, event?: KeyboardEvent) => void
+    ): void;
+    on(
+      type: "keypress" | "keydown",
+      listener: (event?: KeyboardEvent) => void
+    ): void;
+    on(
+      type: "refresh",
+      listener: (data?: {
+        start: number,
+        end: number,
+        ...
+      }) => void
+    ): void;
+    on(
+      type: "resize",
+      listener: (data?: {
+        cols: number,
+        rows: number,
+        ...
+      }) => void
+    ): void;
+    on(type: "scroll", listener: (ydisp?: number) => void): void;
+    on(type: "title", listener: (title?: string) => void): void;
+    on(type: string, listener: (...args: any[]) => void): void;
+    off(
+      type: | "blur"
+      | "focus"
+      | "linefeed"
+      | "selection"
+      | "data"
+      | "key"
+      | "keypress"
+      | "keydown"
+      | "refresh"
+      | "resize"
+      | "scroll"
+      | "title"
+      | string,
+      listener: (...args: any[]) => void
+    ): void;
+    emit(type: string, data?: any): void;
+    addDisposableListener(
+      type: string,
+      handler: (...args: any[]) => void
+    ): Disposable;
+    resize(columns: number, rows: number): void;
+    writeln(data: string): void;
+    open(parent: HTMLElement): void;
+    attachCustomKeyEventHandler(
+      customKeyEventHandler: (event: KeyboardEvent) => boolean
+    ): void;
+    registerLinkMatcher(
+      regex: RegExp,
+      handler: (event: MouseEvent, uri: string) => void,
+      options?: LinkMatcherOptions
+    ): number;
+    deregisterLinkMatcher(matcherId: number): void;
+    addMarker(cursorYOffset: number): Marker;
+    hasSelection(): boolean;
+    getSelection(): string;
+    clearSelection(): void;
+    selectAll(): void;
+    selectLines(start: number, end: number): void;
+    destroy(): void;
+    scrollLines(amount: number): void;
+    scrollPages(pageCount: number): void;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+    scrollToLine(line: number): void;
+    clear(): void;
+    write(data: string): void;
+    getOption(
+      key: | "bellSound"
+      | "bellStyle"
+      | "cursorStyle"
+      | "fontFamily"
+      | "fontWeight"
+      | "fontWeightBold"
+      | "termName"
+    ): string;
+    getOption(
+      key: | "allowTransparency"
+      | "cancelEvents"
+      | "convertEol"
+      | "cursorBlink"
+      | "debug"
+      | "disableStdin"
+      | "enableBold"
+      | "macOptionIsMeta"
+      | "rightClickSelectsWord"
+      | "popOnBell"
+      | "screenKeys"
+      | "useFlowControl"
+      | "visualBell"
+    ): boolean;
+    getOption(key: "colors"): Array<string>;
+    getOption(
+      key: | "cols"
+      | "fontSize"
+      | "letterSpacing"
+      | "lineHeight"
+      | "rows"
+      | "tabStopWidth"
+      | "scrollback"
+    ): number;
+    getOption(key: "handler"): (data: string) => void;
+    getOption(key: string): any;
+    setOption(
+      key: "fontFamily" | "termName" | "bellSound",
+      value: string
+    ): void;
+    setOption(key: "fontWeight" | "fontWeightBold", value: ?FontWeight): void;
+    setOption(
+      key: "bellStyle",
+      value: null | "none" | "visual" | "sound" | "both"
+    ): void;
+    setOption(
+      key: "cursorStyle",
+      value: null | "block" | "underline" | "bar"
+    ): void;
+    setOption(
+      key: | "allowTransparency"
+      | "cancelEvents"
+      | "convertEol"
+      | "cursorBlink"
+      | "debug"
+      | "disableStdin"
+      | "enableBold"
+      | "macOptionIsMeta"
+      | "popOnBell"
+      | "rightClickSelectsWord"
+      | "screenKeys"
+      | "useFlowControl"
+      | "visualBell",
+      value: boolean
+    ): void;
+    setOption(key: "colors", value: Array<string>): void;
+    setOption(
+      key: | "fontSize"
+      | "letterSpacing"
+      | "lineHeight"
+      | "tabStopWidth"
+      | "scrollback",
+      value: number
+    ): void;
+    setOption(key: "handler", value: (data: string) => void): void;
+    setOption(key: "theme", value: Theme): void;
+    setOption(key: "cols" | "rows", value: number): void;
+    setOption(key: string, value: any): void;
+    refresh(start: number, end: number): void;
+    reset(): void;
+    static applyAddon(addon: any): void;
+  }
+}
diff --git a/definitions/npm/yargs_v10.x.x/flow_v0.104.x-/yargs_v10.x.x.js b/definitions/npm/yargs_v10.x.x/flow_v0.104.x-v0.200.x/yargs_v10.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v10.x.x/flow_v0.104.x-/yargs_v10.x.x.js
rename to definitions/npm/yargs_v10.x.x/flow_v0.104.x-v0.200.x/yargs_v10.x.x.js
diff --git a/definitions/npm/yargs_v10.x.x/flow_v0.201.x-/yargs_v10.x.x.js b/definitions/npm/yargs_v10.x.x/flow_v0.201.x-/yargs_v10.x.x.js
new file mode 100644
index 0000000000..ac9512f745
--- /dev/null
+++ b/definitions/npm/yargs_v10.x.x/flow_v0.201.x-/yargs_v10.x.x.js
@@ -0,0 +1,254 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: mixed) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: (argv: Argv) => void
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(key: string, value: string | Array<string>): this;
+    conflicts(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(key: string, value: string | Array<string>): this;
+    implies(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args?: string | Array<string>,
+      context?: { [key: string]: mixed, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    skipValidation(key: string): this;
+
+    strict(global?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string | boolean): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v15.x.x/flow_v0.118.x-/yargs_v15.x.x.js b/definitions/npm/yargs_v15.x.x/flow_v0.118.x-v0.200.x/yargs_v15.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v15.x.x/flow_v0.118.x-/yargs_v15.x.x.js
rename to definitions/npm/yargs_v15.x.x/flow_v0.118.x-v0.200.x/yargs_v15.x.x.js
diff --git a/definitions/npm/yargs_v15.x.x/flow_v0.201.x-/yargs_v15.x.x.js b/definitions/npm/yargs_v15.x.x/flow_v0.201.x-/yargs_v15.x.x.js
new file mode 100644
index 0000000000..7a88abebbf
--- /dev/null
+++ b/definitions/npm/yargs_v15.x.x/flow_v0.201.x-/yargs_v15.x.x.js
@@ -0,0 +1,298 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: any,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: {[key: string]: any, ...} | any) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | Array<string> | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    required: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: ((argv: Argv) => void) | ((argv: Argv) => Promise<void>)
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare type MiddleWareCallback =
+    | (argv: Argv, yargsInstance?: Yargs) => void
+    | (argv: Argv, yargsInstance?: Yargs) => Promise<void>;
+
+  declare type Middleware = MiddleWareCallback | Array<MiddleWareCallback>;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(parameter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    commandDir(
+      directory: string,
+      options?: {
+        exclude?: string | Function,
+        extensions?: Array<string>,
+        include?: string | Function,
+        recurse?: boolean,
+        visit?: Function,
+        ...
+      },
+    ): this;
+
+    completion(
+      cmd?: string,
+      description?: string | false | (
+        current: string,
+        argv: Argv,
+        done: (compeltion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>),
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (completion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(key: string, value: string | Array<string>): this;
+    conflicts(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(): this;
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc?: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option: boolean): this;
+
+    help(option?: string, desc?: string): this;
+
+    hide(key: string): this;
+
+    implies(key: string, value: string | Array<string>): this;
+    implies(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    middleware(
+      middlewareCallbacks: Middleware,
+      applyBeforeValidation?: boolean,
+    ): this;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    onFinishCommand(handler: () => mixed): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args?: string | Array<string>,
+      context?: { [key: string]: any, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    parserConfiguration(configuration: {[key: string]: any, ...}): this;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    positional(key: string, opt?: Options): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    scriptName(name: string): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+    showHelp(printCallback: (usageData: string) => void): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    skipValidation(key: string): this;
+
+    strict(global?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    terminalWidth(): number;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string | false): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v16.x.x/flow_v0.104.x-/yargs_v16.x.x.js b/definitions/npm/yargs_v16.x.x/flow_v0.104.x-v0.200.x/yargs_v16.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v16.x.x/flow_v0.104.x-/yargs_v16.x.x.js
rename to definitions/npm/yargs_v16.x.x/flow_v0.104.x-v0.200.x/yargs_v16.x.x.js
diff --git a/definitions/npm/yargs_v16.x.x/flow_v0.201.x-/yargs_v16.x.x.js b/definitions/npm/yargs_v16.x.x/flow_v0.201.x-/yargs_v16.x.x.js
new file mode 100644
index 0000000000..a5a447d670
--- /dev/null
+++ b/definitions/npm/yargs_v16.x.x/flow_v0.201.x-/yargs_v16.x.x.js
@@ -0,0 +1,301 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: any,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: {[key: string]: any, ...} | any) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | Array<string> | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    hidden: boolean,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    required: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: ((argv: Argv) => void) | ((argv: Argv) => Promise<void>)
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare type MiddleWareCallback =
+    | (argv: Argv, yargsInstance?: Yargs) => void
+    | (argv: Argv, yargsInstance?: Yargs) => Promise<void>;
+
+  declare type Middleware = MiddleWareCallback | Array<MiddleWareCallback>;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(parameter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    commandDir(
+      directory: string,
+      options?: {
+        exclude?: string | Function,
+        extensions?: Array<string>,
+        include?: string | Function,
+        recurse?: boolean,
+        visit?: Function,
+        ...
+      },
+    ): this;
+
+    completion(
+      cmd?: string,
+      description?: string | false | (
+        current: string,
+        argv: Argv,
+        done: (compeltion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>),
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (completion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(key: string, value: string | Array<string>): this;
+    conflicts(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(): this;
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc?: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option: boolean): this;
+
+    help(option?: string, desc?: string): this;
+
+    hide(key: string): this;
+
+    implies(key: string, value: string | Array<string>): this;
+    implies(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    middleware(
+      middlewareCallbacks: Middleware,
+      applyBeforeValidation?: boolean,
+    ): this;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    onFinishCommand(handler: () => mixed): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args?: string | Array<string>,
+      context?: { [key: string]: any, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    parserConfiguration(configuration: {[key: string]: any, ...}): this;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    positional(key: string, opt?: Options): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    scriptName(name: string): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+    showHelp(printCallback: (usageData: string) => void): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    skipValidation(key: string): this;
+
+    strict(enabled?: boolean): this;
+
+    strictCommands(enabled?: boolean): this;
+
+    strictOptions(enabled?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    terminalWidth(): number;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string | false): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v17.x.x/flow_v0.104.x-/yargs_v17.x.x.js b/definitions/npm/yargs_v17.x.x/flow_v0.104.x-v0.200.x/yargs_v17.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v17.x.x/flow_v0.104.x-/yargs_v17.x.x.js
rename to definitions/npm/yargs_v17.x.x/flow_v0.104.x-v0.200.x/yargs_v17.x.x.js
diff --git a/definitions/npm/yargs_v17.x.x/flow_v0.201.x-/yargs_v17.x.x.js b/definitions/npm/yargs_v17.x.x/flow_v0.201.x-/yargs_v17.x.x.js
new file mode 100644
index 0000000000..3aae977fe0
--- /dev/null
+++ b/definitions/npm/yargs_v17.x.x/flow_v0.201.x-/yargs_v17.x.x.js
@@ -0,0 +1,338 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: any,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: {[key: string]: any, ...} | any) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | Array<string> | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    hidden: boolean,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    required: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: ((argv: Argv) => void) | ((argv: Argv) => Promise<void>)
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare type MiddleWareCallback =
+    | (argv: Argv, yargsInstance?: Yargs) => void
+    | (argv: Argv, yargsInstance?: Yargs) => Promise<void>;
+
+  declare type Middleware = MiddleWareCallback | Array<MiddleWareCallback>;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv | Promise<Argv>;
+    array(key: string | Array<string>): this;
+    boolean(parameter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => mixed): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?:
+        | { [key: string]: Options, ... }
+        | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+    command(module: ModuleObject): this;
+
+    commands(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?:
+        | { [key: string]: Options, ... }
+        | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+    commands(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+    commands(module: ModuleObject): this;
+
+    commandDir(
+      directory: string,
+      options?: {
+        exclude?: string | Function,
+        extensions?: Array<string>,
+        include?: string | Function,
+        recurse?: boolean,
+        visit?: Function,
+        ...
+      },
+    ): this;
+
+    completion(
+      cmd?: string,
+      description?: string | false | (
+        current: string,
+        argv: Argv,
+        done: (compeltion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>),
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (completion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(key: string, value: string | Array<string>): this;
+    conflicts(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(): this;
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc?: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(
+      args: Array<string>,
+      fn: (err: Error | null, completions: Array<string> | void) => void
+    ): Promise<Array<string> | void>;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option: boolean): this;
+
+    help(option?: string, desc?: string): this;
+
+    hide(key: string): this;
+
+    implies(key: string, value: string | Array<string>): this;
+    implies(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    middleware(
+      middlewareCallbacks: Middleware,
+      applyBeforeValidation?: boolean,
+    ): this;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args?: string | Array<string>,
+      context?: { [key: string]: any, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv | Promise<Argv>;
+    parse(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv | Promise<Argv>;
+
+    parseAsync(
+      args?: string | Array<string>,
+      context?: { [key: string]: any, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Promise<Argv>;
+    parseAsync(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Promise<Argv>;
+
+    parseSync(
+      args?: string | Array<string>,
+      context?: { [key: string]: any, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parseSync(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    parserConfiguration(configuration: {[key: string]: any, ...}): this;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    positional(key: string, opt?: Options): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    scriptName(name: string): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+    showHelp(printCallback: (usageData: string) => void): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    skipValidation(key: string): this;
+
+    showVersion(consoleLevel?: "error" | "warn" | "log"): this;
+    showVersion(printCallback: (usageData: string) => void): this;
+
+    strict(enabled?: boolean): this;
+
+    strictCommands(enabled?: boolean): this;
+
+    strictOptions(enabled?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    terminalWidth(): number;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string | false): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v4.x.x/flow_v0.104.x-/yargs_v4.x.x.js b/definitions/npm/yargs_v4.x.x/flow_v0.104.x-v0.200.x/yargs_v4.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v4.x.x/flow_v0.104.x-/yargs_v4.x.x.js
rename to definitions/npm/yargs_v4.x.x/flow_v0.104.x-v0.200.x/yargs_v4.x.x.js
diff --git a/definitions/npm/yargs_v5.x.x/flow_v0.104.x-/yargs_v5.x.x.js b/definitions/npm/yargs_v4.x.x/flow_v0.201.x-/yargs_v4.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v5.x.x/flow_v0.104.x-/yargs_v5.x.x.js
rename to definitions/npm/yargs_v4.x.x/flow_v0.201.x-/yargs_v4.x.x.js
diff --git a/definitions/npm/yargs_v5.x.x/flow_v0.104.x-v0.200.x/yargs_v5.x.x.js b/definitions/npm/yargs_v5.x.x/flow_v0.104.x-v0.200.x/yargs_v5.x.x.js
new file mode 100644
index 0000000000..bb66b0aeed
--- /dev/null
+++ b/definitions/npm/yargs_v5.x.x/flow_v0.104.x-v0.200.x/yargs_v5.x.x.js
@@ -0,0 +1,181 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string,
+    array: boolean,
+    choices: Array<any>,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    count: boolean,
+    default: boolean,
+    defaultDescription: string,
+    demand: boolean,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    require: boolean,
+    required: boolean,
+    requiresArg: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type DescParseFn = (configPath: string) => Object;
+
+  declare type ModuleObject = {
+    command: string,
+    describe: string,
+    builder: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler: (argv: Argv) => void,
+    ...
+  };
+
+  declare class Yargs {
+    alias(toBeAliased: string, alias: string): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+
+    command(
+      cmd: string,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(cmd: string, desc: string | false, module: ModuleObject): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Object,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key: string,
+      description?: string | DescParseFn,
+      parseFn?: DescParseFn
+    ): this;
+
+    count(name: string): this;
+
+    default(defaultObject: { [paramter: string]: any, ... }): this;
+    default(parameter: string, value: any): this;
+
+    // Alias of require()!
+    demand(key: string, msg: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    describe(key: string, desc: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldI: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(epi: string): this;
+    epilogue(epi: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string) => mixed): this;
+
+    global(globals: string | Array<string>): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(keyA: string, keyB: string): this;
+    implies(keys: { [key: string]: string, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "tr"
+      | "zh"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(args: string | Array<string>): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    // Alias of demand()!
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel: "error" | "log" | "warn"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(
+      option?: string | (() => string),
+      description?: string | Function,
+      version?: string | Function
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v5.x.x/flow_v0.201.x-/yargs_v5.x.x.js b/definitions/npm/yargs_v5.x.x/flow_v0.201.x-/yargs_v5.x.x.js
new file mode 100644
index 0000000000..bb66b0aeed
--- /dev/null
+++ b/definitions/npm/yargs_v5.x.x/flow_v0.201.x-/yargs_v5.x.x.js
@@ -0,0 +1,181 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string,
+    array: boolean,
+    choices: Array<any>,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    count: boolean,
+    default: boolean,
+    defaultDescription: string,
+    demand: boolean,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    require: boolean,
+    required: boolean,
+    requiresArg: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type DescParseFn = (configPath: string) => Object;
+
+  declare type ModuleObject = {
+    command: string,
+    describe: string,
+    builder: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler: (argv: Argv) => void,
+    ...
+  };
+
+  declare class Yargs {
+    alias(toBeAliased: string, alias: string): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+
+    command(
+      cmd: string,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(cmd: string, desc: string | false, module: ModuleObject): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Object,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key: string,
+      description?: string | DescParseFn,
+      parseFn?: DescParseFn
+    ): this;
+
+    count(name: string): this;
+
+    default(defaultObject: { [paramter: string]: any, ... }): this;
+    default(parameter: string, value: any): this;
+
+    // Alias of require()!
+    demand(key: string, msg: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    describe(key: string, desc: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldI: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(epi: string): this;
+    epilogue(epi: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string) => mixed): this;
+
+    global(globals: string | Array<string>): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(keyA: string, keyB: string): this;
+    implies(keys: { [key: string]: string, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "tr"
+      | "zh"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(args: string | Array<string>): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    // Alias of demand()!
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel: "error" | "log" | "warn"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(
+      option?: string | (() => string),
+      description?: string | Function,
+      version?: string | Function
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v7.x.x/flow_v0.104.x-/yargs_v7.x.x.js b/definitions/npm/yargs_v7.x.x/flow_v0.104.x-v0.200.x/yargs_v7.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v7.x.x/flow_v0.104.x-/yargs_v7.x.x.js
rename to definitions/npm/yargs_v7.x.x/flow_v0.104.x-v0.200.x/yargs_v7.x.x.js
diff --git a/definitions/npm/yargs_v8.x.x/flow_v0.104.x-/yargs_v8.x.x.js b/definitions/npm/yargs_v7.x.x/flow_v0.201.x-/yargs_v7.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v8.x.x/flow_v0.104.x-/yargs_v8.x.x.js
rename to definitions/npm/yargs_v7.x.x/flow_v0.201.x-/yargs_v7.x.x.js
diff --git a/definitions/npm/yargs_v8.x.x/flow_v0.104.x-v0.200.x/yargs_v8.x.x.js b/definitions/npm/yargs_v8.x.x/flow_v0.104.x-v0.200.x/yargs_v8.x.x.js
new file mode 100644
index 0000000000..ef55cd382b
--- /dev/null
+++ b/definitions/npm/yargs_v8.x.x/flow_v0.104.x-v0.200.x/yargs_v8.x.x.js
@@ -0,0 +1,254 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: mixed) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: (argv: Argv) => void
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(keyA: string, keyB: string): this;
+    conflicts(keys: { [key: string]: string, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(keyA: string, keyB: string): this;
+    implies(keys: { [key: string]: string, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args: string | Array<string>,
+      context?: { [key: string]: mixed, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    skipValidation(key: string): this;
+
+    strict(global?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v8.x.x/flow_v0.201.x-/yargs_v8.x.x.js b/definitions/npm/yargs_v8.x.x/flow_v0.201.x-/yargs_v8.x.x.js
new file mode 100644
index 0000000000..ef55cd382b
--- /dev/null
+++ b/definitions/npm/yargs_v8.x.x/flow_v0.201.x-/yargs_v8.x.x.js
@@ -0,0 +1,254 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: mixed) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: (argv: Argv) => void
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(keyA: string, keyB: string): this;
+    conflicts(keys: { [key: string]: string, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(keyA: string, keyB: string): this;
+    implies(keys: { [key: string]: string, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args: string | Array<string>,
+      context?: { [key: string]: mixed, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    skipValidation(key: string): this;
+
+    strict(global?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yargs_v9.x.x/flow_v0.104.x-/yargs_v9.x.x.js b/definitions/npm/yargs_v9.x.x/flow_v0.104.x-v0.200.x/yargs_v9.x.x.js
similarity index 100%
rename from definitions/npm/yargs_v9.x.x/flow_v0.104.x-/yargs_v9.x.x.js
rename to definitions/npm/yargs_v9.x.x/flow_v0.104.x-v0.200.x/yargs_v9.x.x.js
diff --git a/definitions/npm/yargs_v9.x.x/flow_v0.201.x-/yargs_v9.x.x.js b/definitions/npm/yargs_v9.x.x/flow_v0.201.x-/yargs_v9.x.x.js
new file mode 100644
index 0000000000..9c8600fe70
--- /dev/null
+++ b/definitions/npm/yargs_v9.x.x/flow_v0.201.x-/yargs_v9.x.x.js
@@ -0,0 +1,254 @@
+declare module "yargs" {
+  declare type Argv = {
+    [key: string]: mixed,
+    _: Array<string>,
+    $0: string,
+    ...
+  };
+
+  declare type Options = $Shape<{
+    alias: string | Array<string>,
+    array: boolean,
+    boolean: boolean,
+    choices: Array<mixed>,
+    coerce: (arg: mixed) => mixed,
+    config: boolean,
+    configParser: (configPath: string) => { [key: string]: mixed, ... },
+    conflicts: string | { [key: string]: string, ... },
+    count: boolean,
+    default: mixed,
+    defaultDescription: string,
+    demandOption: boolean | string,
+    desc: string,
+    describe: string,
+    description: string,
+    global: boolean,
+    group: string,
+    implies: string | { [key: string]: string, ... },
+    nargs: number,
+    normalize: boolean,
+    number: boolean,
+    requiresArg: boolean,
+    skipValidation: boolean,
+    string: boolean,
+    type: "array" | "boolean" | "count" | "number" | "string",
+    ...
+  }>;
+
+  declare type CommonModuleObject = {|
+    command?: string | Array<string>,
+    aliases?: Array<string> | string,
+    builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+    handler?: (argv: Argv) => void
+  |};
+
+  declare type ModuleObjectDesc = {|
+    ...CommonModuleObject,
+    desc?: string | false
+  |};
+
+  declare type ModuleObjectDescribe = {|
+    ...CommonModuleObject,
+    describe?: string | false
+  |};
+
+  declare type ModuleObjectDescription = {|
+    ...CommonModuleObject,
+    description?: string | false
+  |};
+
+  declare type ModuleObject =
+    | ModuleObjectDesc
+    | ModuleObjectDescribe
+    | ModuleObjectDescription;
+
+  declare class Yargs {
+    (args: Array<string>): Yargs;
+
+    alias(key: string, alias: string): this;
+    alias(alias: { [key: string]: string | Array<string>, ... }): this;
+    argv: Argv;
+    array(key: string | Array<string>): this;
+    boolean(paramter: string | Array<string>): this;
+    check(fn: (argv: Argv, options: Array<string>) => ?boolean): this;
+    choices(key: string, allowed: Array<string>): this;
+    choices(allowed: { [key: string]: Array<string>, ... }): this;
+    coerce(key: string, fn: (value: any) => mixed): this;
+    coerce(object: { [key: string]: (value: any) => mixed, ... }): this;
+    coerce(keys: Array<string>, fn: (value: any) => mixed): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      builder?: { [key: string]: Options, ... } | ((yargsInstance: Yargs) => mixed),
+      handler?: Function
+    ): this;
+
+    command(
+      cmd: string | Array<string>,
+      desc: string | false,
+      module: ModuleObject
+    ): this;
+
+    command(module: ModuleObject): this;
+
+    completion(
+      cmd: string,
+      description?: string,
+      fn?: (
+        current: string,
+        argv: Argv,
+        done: (competion: Array<string>) => void
+      ) => ?(Array<string> | Promise<Array<string>>)
+    ): this;
+
+    config(
+      key?: string,
+      description?: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(
+      key: string,
+      parseFn?: (configPath: string) => { [key: string]: mixed, ... }
+    ): this;
+    config(config: { [key: string]: mixed, ... }): this;
+
+    conflicts(key: string, value: string | Array<string>): this;
+    conflicts(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    count(name: string): this;
+
+    default(key: string, value: mixed, description?: string): this;
+    default(defaults: { [key: string]: mixed, ... }): this;
+
+    // Deprecated: use demandOption() and demandCommand() instead.
+    demand(key: string, msg?: string | boolean): this;
+    demand(count: number, max?: number, msg?: string | boolean): this;
+
+    demandOption(key: string | Array<string>, msg?: string | boolean): this;
+
+    demandCommand(min: number, minMsg?: string): this;
+    demandCommand(
+      min: number,
+      max: number,
+      minMsg?: string,
+      maxMsg?: string
+    ): this;
+
+    describe(key: string, description: string): this;
+    describe(describeObject: { [key: string]: string, ... }): this;
+
+    detectLocale(shouldDetect: boolean): this;
+
+    env(prefix?: string): this;
+
+    epilog(text: string): this;
+    epilogue(text: string): this;
+
+    example(cmd: string, desc: string): this;
+
+    exitProcess(enable: boolean): this;
+
+    fail(fn: (failureMessage: string, err: Error, yargs: Yargs) => mixed): this;
+
+    getCompletion(args: Array<string>, fn: () => void): this;
+
+    global(globals: string | Array<string>, isGlobal?: boolean): this;
+
+    group(key: string | Array<string>, groupName: string): this;
+
+    help(option?: string, desc?: string): this;
+
+    implies(key: string, value: string | Array<string>): this;
+    implies(keys: { [key: string]: string | Array<string>, ... }): this;
+
+    locale(
+      locale: | "de"
+      | "en"
+      | "es"
+      | "fr"
+      | "hi"
+      | "hu"
+      | "id"
+      | "it"
+      | "ja"
+      | "ko"
+      | "nb"
+      | "pirate"
+      | "pl"
+      | "pt"
+      | "pt_BR"
+      | "ru"
+      | "th"
+      | "tr"
+      | "zh_CN"
+    ): this;
+    locale(): string;
+
+    nargs(key: string, count: number): this;
+
+    normalize(key: string): this;
+
+    number(key: string | Array<string>): this;
+
+    option(key: string, options?: Options): this;
+    option(optionMap: { [key: string]: Options, ... }): this;
+
+    options(key: string, options?: Options): this;
+    options(optionMap: { [key: string]: Options, ... }): this;
+
+    parse(
+      args?: string | Array<string>,
+      context?: { [key: string]: mixed, ... },
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+    parse(
+      args?: string | Array<string>,
+      parseCallback?: (err: Error, argv: Argv, output?: string) => void
+    ): Argv;
+
+    pkgConf(key: string, cwd?: string): this;
+
+    recommendCommands(): this;
+
+    // Alias of demand()
+    require(key: string, msg: string | boolean): this;
+    require(count: number, max?: number, msg?: string | boolean): this;
+
+    requiresArg(key: string | Array<string>): this;
+
+    reset(): this;
+
+    showCompletionScript(): this;
+
+    showHelp(consoleLevel?: "error" | "warn" | "log"): this;
+
+    showHelpOnFail(enable: boolean, message?: string): this;
+
+    strict(): this;
+
+    skipValidation(key: string): this;
+
+    strict(global?: boolean): this;
+
+    string(key: string | Array<string>): this;
+
+    updateLocale(obj: { [key: string]: string, ... }): this;
+    updateStrings(obj: { [key: string]: string, ... }): this;
+
+    usage(message: string, opts?: { [key: string]: Options, ... }): this;
+
+    version(): this;
+    version(version: string): this;
+    version(option: string | (() => string), version: string): this;
+    version(
+      option: string | (() => string),
+      description: string | (() => string),
+      version: string
+    ): this;
+
+    wrap(columns: number | null): this;
+  }
+
+  declare module.exports: Yargs;
+}
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.104.x-/test_imports.js b/definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/test_imports.js
similarity index 100%
rename from definitions/npm/yup_v0.x.x/flow_v0.104.x-/test_imports.js
rename to definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/test_imports.js
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.104.x-/test_yup.js b/definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/test_yup.js
similarity index 100%
rename from definitions/npm/yup_v0.x.x/flow_v0.104.x-/test_yup.js
rename to definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/test_yup.js
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.104.x-/yup_v0.x.x.js b/definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/yup_v0.x.x.js
similarity index 100%
rename from definitions/npm/yup_v0.x.x/flow_v0.104.x-/yup_v0.x.x.js
rename to definitions/npm/yup_v0.x.x/flow_v0.104.x-v0.200.x/yup_v0.x.x.js
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_imports.js b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_imports.js
new file mode 100644
index 0000000000..dff1d59671
--- /dev/null
+++ b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_imports.js
@@ -0,0 +1,32 @@
+// @flow
+import {
+  setLocale,
+  isSchema,
+  reach,
+  array,
+  bool,
+  boolean,
+  date,
+  mixed,
+  number,
+  object,
+  string,
+  lazy,
+  ref,
+  addMethod,
+} from 'yup';
+
+import array2 from 'yup/lib/array';
+import bool2 from 'yup/lib/bool';
+import boolean2 from 'yup/lib/boolean';
+import date2 from 'yup/lib/date';
+import Lazy from 'yup/lib/Lazy';
+import mixed2 from 'yup/lib/mixed';
+import number2 from 'yup/lib/number';
+import object2 from 'yup/lib/object';
+import Reference from 'yup/lib/Reference';
+import setLocale2 from 'yup/lib/setLocale';
+import string2 from 'yup/lib/string';
+import isSchema2 from 'yup/lib/util/isSchema';
+import reach2 from 'yup/lib/util/reach';
+import ValidationError from 'yup/lib/ValidationError';
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_yup.js b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_yup.js
new file mode 100644
index 0000000000..56a2e70ef8
--- /dev/null
+++ b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/test_yup.js
@@ -0,0 +1,1041 @@
+// @flow
+import {
+  isSchema,
+  setLocale,
+  array,
+  bool,
+  date,
+  mixed,
+  string,
+  number,
+  ref,
+  object,
+  type Schema,
+} from 'yup';
+import { it, describe } from 'flow-typed-test';
+
+it('should return boolean when calling isSchema', () => {
+  (isSchema(null): boolean);
+});
+
+describe('setLocale', () => {
+  it('should work properly', () => {
+    (setLocale({
+      mixed: {
+        notType: () => 'ой',
+        required: 'Заполни',
+      },
+      string: {
+        email: 'Введи нормальный э-майл адрес ганчар',
+      },
+    }): void);
+  });
+
+  it('should raise an error when passing object with missing key', () => {
+    // $FlowExpectedError: `abc` is missing
+    setLocale({ abc: { test: 'test' } });
+  });
+
+  it('should raise an error when passing invalid locale object', () => {
+    // $FlowExpectedError: `min__` is missing
+    setLocale({ number: { min__: 'test' } });
+  });
+});
+
+describe('bool & boolean', () => {
+  const instance = new bool();
+  const instance2 = bool();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired();
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need boolean');
+
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = bool()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: boolean);
+      // $FlowExpectedError: check any
+      (val1: number);
+
+      const val2 = bool()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?boolean);
+      // $FlowExpectedError: check any
+      (val2: number);
+
+      const val3 = bool()
+        .required()
+        .validateSync(null);
+
+      (val3: boolean);
+      // $FlowExpectedError: check any
+      (val3: number);
+
+      const val4 = bool()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?boolean);
+      // $FlowExpectedError: check any
+      (val4: number);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(bool())
+          .strict(true)
+          .strip(false)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .oneOf([true, false])
+          .notOneOf([false, true])
+          .when('key', { is: true, then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: boolean);
+
+          // $FlowExpectedError: check any
+          (val: number);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('number', () => {
+  const instance = new number();
+  const instance2 = number();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired()
+          .min(1)
+          .min(1, 'message')
+          .max(1)
+          .max(1, 'message')
+          .lessThan(1)
+          .lessThan(1, 'message')
+          .moreThan(1)
+          .moreThan(1, 'message')
+          .positive()
+          .negative()
+          .integer()
+          .positive('message')
+          .positive(() => 'message')
+          .negative('message')
+          .negative(() => 'message')
+          .integer('message')
+          .integer(() => 'message')
+          .truncate()
+          .round('floor');
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need number');
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+        // $FlowExpectedError
+        schema.min('need a number');
+        // $FlowExpectedError
+        schema.min(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.max('need a number');
+        // $FlowExpectedError
+        schema.max(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.lessThan('need a number');
+        // $FlowExpectedError
+        schema.lessThan(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.moreThan('need a number');
+        // $FlowExpectedError
+        schema.moreThan(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.positive({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.negative({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.integer({ need: 'func or string' });
+        // $FlowExpectedError: `__floor` is missing in enum
+        schema.round('__floor');
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = number()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: number);
+      // $FlowExpectedError: check any
+      (val1: string);
+
+      const val2 = number()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?number);
+      // $FlowExpectedError: check any
+      (val2: string);
+
+      const val3 = number()
+        .required()
+        .validateSync(null);
+
+      (val3: number);
+      // $FlowExpectedError: check any
+      (val3: string);
+
+      const val4 = number()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?number);
+      // $FlowExpectedError: check any
+      (val4: string);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(number())
+          .strict(true)
+          .strip(false)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .oneOf([1, 2])
+          .notOneOf([1, 2, 3])
+          .when('key', { is: '12', then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: number);
+
+          // $FlowExpectedError: check any
+          (val: string);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('string', () => {
+  const instance = new string();
+  const instance2 = string();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired()
+          .min(1)
+          .min(1, 'message')
+          .max(1)
+          .max(1, 'message')
+          .length(1)
+          .length(1, 'message')
+          .email()
+          .email('message')
+          .url()
+          .url('message')
+          .trim()
+          .trim('message')
+          .lowercase()
+          .lowercase('message')
+          .uppercase()
+          .uppercase('message')
+          .ensure()
+          .matches(/a/g)
+          .matches(/a/g, 'message');
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need string');
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+        // $FlowExpectedError
+        schema.min('need a number');
+        // $FlowExpectedError
+        schema.min(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.max('need a number');
+        // $FlowExpectedError
+        schema.max(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.length('need a number');
+        // $FlowExpectedError
+        schema.length(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.email({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.url({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.trim({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.lowercase({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.uppercase({ need: 'func or string' });
+        // $FlowExpectedError
+        schema.matches('need RegExp');
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = string()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: string);
+      // $FlowExpectedError: check any
+      (val1: number);
+
+      const val2 = string()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?string);
+      // $FlowExpectedError: check any
+      (val2: number);
+
+      const val3 = string()
+        .required()
+        .validateSync(null);
+
+      (val3: string);
+      // $FlowExpectedError: check any
+      (val3: number);
+
+      const val4 = string()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?string);
+      // $FlowExpectedError: check any
+      (val4: number);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(string())
+          .strict(true)
+          .strip(false)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .oneOf(['1', '2'])
+          .notOneOf(['3', '3'])
+          .when('key', { is: true, then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: string);
+
+          // $FlowExpectedError: check any
+          (val: number);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('array', () => {
+  const instance = new array();
+  const instance2 = array<number>();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired()
+          .min(1)
+          .min(1, 'message')
+          .max(1)
+          .max(1, 'message')
+          .ensure()
+          .compact(() => true)
+          .of(number());
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need string');
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+        // $FlowExpectedError
+        schema.min('need a number');
+        // $FlowExpectedError
+        schema.min(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.max('need a number');
+        // $FlowExpectedError
+        schema.max(1, { need: 'func or string' });
+        // $FlowExpectedError
+        schema.compact('need function');
+        // $FlowExpectedError need yup schema
+        schema.of(123);
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = array<number>()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: Array<number>);
+      // $FlowExpectedError: check any
+      (val1: number);
+
+      const val2 = array<number>()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?Array<number>);
+      // $FlowExpectedError: check any
+      (val2: number);
+
+      const val3 = array<number>()
+        .required()
+        .validateSync(null);
+
+      (val3: Array<number>);
+      // $FlowExpectedError: check any
+      (val3: number);
+
+      const val4 = array<number>()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?Array<number>);
+      // $FlowExpectedError: check any
+      (val4: number);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(array<number>())
+          .strict(false)
+          .strip(true)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .when('key', { is: true, then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: Array<number>);
+
+          // $FlowExpectedError: check any
+          (val: number);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('date', () => {
+  const instance = new date();
+  const instance2 = date();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired()
+          .min(new Date())
+          .min(new Date(), 'message')
+          .max(new Date())
+          .max(new Date(), 'message');
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need Date');
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+
+        // $FlowExpectedError: need Date or string or Ref
+        schema.min(123);
+        // $FlowExpectedError
+        schema.min(new Date(), { need: 'func or string' });
+        // $FlowExpectedError: need Date or string or Ref
+        schema.max(123);
+        // $FlowExpectedError
+        schema.max(new Date(), { need: 'func or string' });
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = date()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: Date);
+      // $FlowExpectedError: check any
+      (val1: string);
+
+      const val2 = date()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?Date);
+      // $FlowExpectedError: check any
+      (val2: string);
+
+      const val3 = date()
+        .required()
+        .validateSync(null);
+
+      (val3: Date);
+      // $FlowExpectedError: check any
+      (val3: string);
+
+      const val4 = date()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?Date);
+      // $FlowExpectedError: check any
+      (val4: string);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(date())
+          .strict(true)
+          .strip(false)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .oneOf([new Date(), new Date()])
+          .notOneOf([new Date(), new Date()])
+          .when('key', { is: '12', then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: Date);
+
+          // $FlowExpectedError: check any
+          (val: string);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('mixed', () => {
+  const instance = new mixed();
+  const instance2 = mixed();
+
+  describe('own methods', () => {
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .nullable()
+          .nullable(true)
+          .nullable(false)
+          .required()
+          .required('message')
+          .required(() => 'message')
+          .notRequired();
+      });
+    });
+
+    it('should raise an error when passing incompatible arguments', () => {
+      [instance, instance2].map(schema => {
+        // $FlowExpectedError
+        schema.nullable('need mixed');
+
+        // $FlowExpectedError
+        schema.required({ need: 'function or string' });
+      });
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = mixed()
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: mixed);
+      // $FlowExpectedError: check any
+      (val1: number);
+
+      const val2 = mixed()
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?mixed);
+      // $FlowExpectedError: check any
+      (val2: number);
+
+      const val3 = mixed()
+        .required()
+        .validateSync(null);
+
+      (val3: mixed);
+      // $FlowExpectedError: check any
+      (val3: number);
+
+      const val4 = mixed()
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?mixed);
+      // $FlowExpectedError: check any
+      (val4: number);
+    });
+
+    it('should work properly', () => {
+      [instance, instance2].map(schema => {
+        schema
+          .clone()
+          .label('str')
+          .meta({ meta: 'data' })
+          .concat(mixed())
+          .strict(true)
+          .strip(false)
+          .default('any value')
+          .typeError()
+          .typeError('message')
+          .typeError(() => 'message')
+          .oneOf([true, 1])
+          .notOneOf(['false', true])
+          .when('key', { is: true, then: number(), otherwise: string() })
+          .when(['key'], (other, schema) =>
+            other === 4 ? schema.clone() : schema
+          )
+          .test('name', 'message', () => true)
+          .test({
+            test: () => Promise.resolve(true),
+            name: 'name',
+            message: 'message',
+            params: {},
+            exclusive: true,
+          })
+          .test({
+            test: () => Promise.resolve(true),
+          })
+          .transform((a, b) => a + b)
+          .clone();
+
+        schema.validate(null).then(val => {
+          (val: mixed);
+
+          // $FlowExpectedError: check any
+          (val: number);
+        });
+
+        schema.validate(null, {
+          path: 'foo.baz',
+          strict: true,
+          abortEarly: true,
+          stripUnknown: true,
+          recursive: true,
+          context: {},
+        });
+      });
+    });
+  });
+});
+
+describe('object', () => {
+  it('should make valid schema type', () => {
+    (object({
+      a: number(),
+      b: object({
+        c: string(),
+      }),
+      d: ref<string>('b.c'),
+    }): Schema<{
+      a: number,
+      b: { c: string, ... },
+      d: string,
+      ...
+    }, any>);
+  });
+
+  it('should extend schema type by .shape()', () => {
+    const schema = object().shape({
+      a: number(),
+      b: bool(),
+    });
+
+    (schema: Schema<{
+      a: number,
+      b: boolean,
+      ...
+    }, any>);
+
+    (schema: Schema<
+      {
+        // $FlowExpectedError: check any
+        a: string,
+        b: boolean,
+        ...
+      },
+      any
+    >);
+
+    (schema: Schema<
+      {
+        a: number,
+        // $FlowExpectedError: check any
+        b: string,
+        ...
+      },
+      any
+    >);
+  });
+
+  describe('object().from(...)', () => {
+    it('should extend current object type when alias is true', () => {
+      const schema = object({ a: string() }).from('a', 'a2', true);
+
+      (schema: Schema<
+        {
+          a: string,
+          a2: string,
+          ...
+        },
+        any
+      >);
+
+      (schema: Schema<
+        {
+          a: string,
+          // $FlowExpectedError: check any
+          a2: number,
+          ...
+        },
+        any
+      >);
+    });
+
+    it('should return passed type when alias false', () => {
+      const schema = object({ a: string() }).from<{ a2: string, ... }>(
+        'a',
+        'a2',
+        false
+      );
+
+      (schema: Schema<{ a2: string, ... }, any>);
+
+      // $FlowExpectedError: check any
+      (schema: Schema<{ a2: number, ... }, any>);
+
+      // $FlowExpectedError: a missing in new shema
+      (schema: Schema<{ a: number, ... }, any>);
+    });
+  });
+
+  describe('common schema methods', () => {
+    it('should modify type by `nullable` and `required*` methods', () => {
+      const val1 = object({ a: number() })
+        .nullable(false)
+        .validateSync(null);
+
+      (val1: { a: number, ... });
+      // $FlowExpectedError: check any
+      (val1: number);
+
+      const val2 = object({ a: number() })
+        .nullable()
+        .validateSync(null);
+
+      (val2: ?{ a: number, ... });
+      // $FlowExpectedError: check any
+      (val2: number);
+
+      const val3 = object({ a: number() })
+        .required()
+        .validateSync(null);
+
+      (val3: { a: number, ... });
+      // $FlowExpectedError: check any
+      (val3: number);
+
+      const val4 = object({ a: number() })
+        .notRequired()
+        .validateSync(null);
+
+      (val4: ?{ a: number, ... });
+      // $FlowExpectedError: check any
+      (val4: number);
+    });
+
+    it('should work properly', () => {
+      const schema = object({ a: string() });
+
+      schema
+        .clone()
+        .label('str')
+        .meta({ meta: 'data' })
+        .strict(true)
+        .strip(false)
+        .default('any value')
+        .typeError()
+        .typeError('message')
+        .typeError(() => 'message')
+        .oneOf([{ a: '1' }, { a: '2' }])
+        .notOneOf([{ a: '1' }, { a: '2' }])
+        .when('key', { is: true, then: number(), otherwise: string() })
+        .when(['key'], (other, schema) =>
+          other === 4 ? schema.clone() : schema
+        )
+        .test('name', 'message', () => true)
+        .test({
+          test: () => Promise.resolve(true),
+          name: 'name',
+          message: 'message',
+          params: {},
+          exclusive: true,
+        })
+        .test({
+          test: () => Promise.resolve(true),
+        })
+        .transform((a, b) => a + b)
+        .clone();
+
+      schema.validate(null).then(val => {
+        (val: { a: string, ... });
+
+        // $FlowExpectedError: check any
+        (val: number);
+      });
+
+      schema.validate(null, {
+        path: 'foo.baz',
+        strict: true,
+        abortEarly: true,
+        stripUnknown: true,
+        recursive: true,
+        context: {},
+      });
+    });
+  });
+});
+
+it('should work properly when use inherited interface methods', () => {
+  string()
+    .resolve() // method from `BaseSchema` interface
+    .clone() // method from `Schema` interface
+    .required(); // method from `StringSchema` interface
+});
diff --git a/definitions/npm/yup_v0.x.x/flow_v0.201.x-/yup_v0.x.x.js b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/yup_v0.x.x.js
new file mode 100644
index 0000000000..f6b24c511e
--- /dev/null
+++ b/definitions/npm/yup_v0.x.x/flow_v0.201.x-/yup_v0.x.x.js
@@ -0,0 +1,542 @@
+declare module 'yup' {
+  import type Ref from 'yup/lib/Reference';
+  import type Lazy from 'yup/lib/Lazy';
+  import type ValidationError from 'yup/lib/ValidationError';
+
+  declare export type TestOptionsMessage =
+    | string
+    | ((params: $Shape<TestMessageParams>) => string);
+
+  declare export type SchemaMeta = any;
+
+  declare export type ValidateOptions = {|
+    // When call `validate(value, {sync: true})` result will be not passed `value`
+    // sync?: boolean,
+    path?: string,
+    strict?: boolean,
+    abortEarly?: boolean,
+    stripUnknown?: boolean,
+    recursive?: boolean,
+    context?: {...},
+  |};
+
+  declare export interface BaseSchema<T, GetHighType> {
+    cast(value: any, options?: { context: {...}, ... }): T;
+    resolve(options?: any): $Call<GetHighType, T>;
+    validate(value: any, options?: ValidateOptions): Promise<T>;
+    validateSync(
+      value: any,
+      options?: $Diff<ValidateOptions, { sync: any, ... }>
+    ): T;
+    validateAt(
+      path: string,
+      value: T,
+      options?: $Diff<ValidateOptions, { path: any, ... }>
+    ): Promise<T>;
+    validateSyncAt(
+      path: string,
+      value: T,
+      options?: $Diff<ValidateOptions, {
+        sync: any,
+        path: any,
+        ...
+      }>
+    ): T;
+  }
+
+  declare export interface Schema<T, GetHighType>
+    extends BaseSchema<T, GetHighType> {
+    clone(): $Call<GetHighType, T>;
+    label(label: string): $Call<GetHighType, T>;
+    meta(metadata: SchemaMeta): $Call<GetHighType, T>;
+    meta(): SchemaMeta;
+    describe(): SchemaDescription;
+    concat(schema: $Call<GetHighType, T>): $Call<GetHighType, T>;
+    isValid(value: any, options?: ValidateOptions): Promise<boolean>;
+    isValidSync(
+      value: any,
+      options?: $Diff<ValidateOptions, { sync: any, ... }>
+    ): boolean;
+
+    isType(value: any): boolean;
+    strict(isStrict: boolean): $Call<GetHighType, T>;
+    strip(strip: boolean): $Call<GetHighType, T>;
+    withMutation(fn: (current: $Call<GetHighType, T>) => mixed): void;
+    default(value: any): $Call<GetHighType, T>;
+    default(): T;
+    typeError(message?: TestOptionsMessage): $Call<GetHighType, T>;
+    oneOf(
+      arrayOfValues: $ReadOnlyArray<T>,
+      message?: TestOptionsMessage
+    ): $Call<GetHighType, T>;
+    notOneOf(
+      arrayOfValues: $ReadOnlyArray<T>,
+      message?: TestOptionsMessage
+    ): $Call<GetHighType, T>;
+    when(
+      keys: string | $ReadOnlyArray<string>,
+      builder: WhenOptions<Schema<T, GetHighType>>
+    ): $Call<GetHighType, T>;
+    test(
+      name: string,
+      message: TestOptionsMessage,
+      test: (
+        value?: any
+      ) => boolean | ValidationError | Promise<boolean | ValidationError>
+    ): $Call<GetHighType, T>;
+    test(options: TestOptions): $Call<GetHighType, T>;
+    transform(fn: TransformFunction): $Call<GetHighType, T>;
+  }
+
+  declare export type TransformFunction = (
+    value: any,
+    originalValue: any
+  ) => any;
+
+  declare export interface WhenOptionsBuilderFunction<T> {
+    (value: any, schema: T, ...rest: Array<empty>): T;
+    (v1: any, v2: any, schema: T, ...rest: Array<empty>): T;
+    (v1: any, v2: any, v3: any, schema: T, ...rest: Array<empty>): T;
+    (v1: any, v2: any, v3: any, v4: any, schema: T, ...rest: Array<empty>): T;
+  }
+
+  declare export type WhenOptionsBuilderObjectIs =
+    | ((...values: any) => boolean)
+    | boolean
+    | number
+    | string
+    | null
+    | void
+    | {...};
+
+  declare export type WhenOptionsBuilderObject = {|
+    is: WhenOptionsBuilderObjectIs,
+    then: Schema<any, any>,
+    otherwise: Schema<any, any>,
+  |};
+
+  declare export type WhenOptions<T> =
+    | WhenOptionsBuilderFunction<T>
+    | WhenOptionsBuilderObject;
+
+  declare export type TestMessageParams = {|
+    path: string,
+    value: any,
+    originalValue: any,
+    label: string,
+  |};
+
+  declare export type TestOptions = {|
+    name?: string,
+    test: (
+      value: any
+    ) => boolean | ValidationError | Promise<boolean | ValidationError>,
+    message?: TestOptionsMessage,
+    params?: {...},
+    exclusive?: boolean,
+  |};
+
+  declare export type SchemaDescription = {
+    type: string,
+    label: string,
+    meta: {...},
+    tests: Array<{
+      name: string,
+      params: {...},
+      ...
+    }>,
+    ...
+  };
+
+  declare export function ref<T>(
+    path: string,
+    options?: {| contextPrefix: string |}
+  ): Ref<T>;
+
+  declare export function lazy<T>(fn: (value: T) => Schema<T, any>): Lazy;
+
+  declare export { default as setLocale } from 'yup/lib/setLocale';
+  declare export { default as isSchema } from 'yup/lib/util/isSchema';
+  declare export { default as reach } from 'yup/lib/util/reach';
+
+  declare export { default as array } from 'yup/lib/array';
+  declare export { default as bool } from 'yup/lib/bool';
+  declare export { default as boolean } from 'yup/lib/boolean';
+  declare export { default as date } from 'yup/lib/date';
+  declare export { default as mixed } from 'yup/lib/mixed';
+  declare export { default as number } from 'yup/lib/number';
+  declare export { default as object } from 'yup/lib/object';
+  declare export { default as string } from 'yup/lib/string';
+
+  declare export function addMethod(
+    schemaType: any,
+    name: string,
+    method: (...args: any) => mixed
+  ): void;
+}
+
+declare module 'yup/lib/setLocale' {
+  declare export type LocaleDescriptor<Keys> = { [Keys]: string, ... };
+
+  declare export type LocaleObject = {|
+    mixed?: {
+      ['default' | 'required' | 'oneOf' | 'notOneOf']: string,
+      notType: ({|
+        path: string,
+        type: any,
+        value: any,
+        originalValue: any,
+      |}) => string,
+      ...
+    },
+    string?: LocaleDescriptor<
+      | 'length'
+      | 'min'
+      | 'max'
+      | 'matches'
+      | 'email'
+      | 'url'
+      | 'trim'
+      | 'lowercase'
+      | 'uppercase'
+    >,
+    number?: LocaleDescriptor<
+      | 'min '
+      | 'max'
+      | 'lessThan'
+      | 'moreThan'
+      | 'notEqual'
+      | 'positive'
+      | 'negative'
+      | 'integer'
+    >,
+    boolean?: {...},
+    bool?: {...},
+    date?: LocaleDescriptor<'min' | 'max'>,
+    array?: LocaleDescriptor<'min' | 'max'>,
+    object?: LocaleDescriptor<'noUnknown'>,
+  |};
+
+  declare export default (customLocale: LocaleObject) => void;
+}
+
+declare module 'yup/lib/ValidationError' {
+  declare export default class ValidationError extends Error {
+    name: string;
+    message: string;
+    value: any;
+    path: string;
+    type: any;
+    errors: Array<string>;
+    inner: Array<ValidationError>;
+    params?: {...};
+
+    static isError(err: any): boolean;
+    static formatError(
+      message: string | ((params?: any) => string),
+      params?: any
+    ): string | ((params?: any) => string);
+
+    constructor(
+      errors: string | Array<string>,
+      value: any,
+      path: string,
+      type?: any
+    ): ValidationError;
+  }
+}
+declare module 'yup/lib/Lazy' {
+  import type { BaseSchema } from 'yup';
+
+  declare export default Class<BaseSchema<any, any>>;
+}
+declare module 'yup/lib/Reference' {
+  import type { BaseSchema } from 'yup';
+  declare export type RefOptions = {| contextPrefix: string |};
+
+  declare export default class Reference<T> implements BaseSchema<T, any> {
+    +__isYupRef: true;
+
+    constructor(key: string, options: RefOptions): Reference<T>;
+    getValue(options: {...}): any;
+    cast(value: any, options: {...}): any;
+    resolve(): Reference<T>;
+    describe(): {| type: 'ref', key: string |};
+
+    static isRef(value: any): boolean;
+
+    /*
+    `implements BaseSchema<T,any>` - This is dirty hack witch using for next case:
+
+     const schema = object({
+       a: object({
+         b: string()
+       })
+       refB: ref<string>('a.b')
+     });
+
+     // Result Type => { a { b: string }, refB: string };
+    */
+    cast: empty;
+    validate: empty;
+    validateAt: empty;
+    validateSync: empty;
+    validateSyncAt: empty;
+  }
+}
+
+declare module 'yup/lib/util/reach' {
+  import type { Schema } from 'yup';
+
+  declare export default { <T, GetterFn, R, ReturnGetterFn>(
+    schema: Schema<T, GetterFn>,
+    path: string,
+    value?: any,
+    context?: any
+  ): Schema<R, ReturnGetterFn>, ... };
+}
+declare module 'yup/lib/util/isSchema' {
+  declare export default (obj: any) => boolean;
+}
+
+declare module 'yup/lib/mixed' {
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type GetterMixedSchema = <T>(T) => MixedSchema<T>;
+
+  declare export type MixedSchemaConstructor = Class<MixedSchema<mixed>> &
+    (() => MixedSchema<mixed>);
+
+  declare export interface MixedSchema<T> extends Schema<T, GetterMixedSchema> {
+    nullable(isNullable?: true): MixedSchema<?T>;
+    nullable(isNullable: false): MixedSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): MixedSchema<$NonMaybeType<T>>;
+    notRequired(): MixedSchema<?T>;
+  }
+
+  declare export default MixedSchemaConstructor;
+}
+declare module 'yup/lib/string' {
+  import type Ref from 'yup/lib/Reference';
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type StringSchemaConstructor = Class<StringSchema<string>> &
+    (() => StringSchema<string>);
+
+  declare export type GetterStringSchema = <T>(T) => StringSchema<T>;
+
+  declare export interface StringSchema<T>
+    extends Schema<T, GetterStringSchema> {
+    length(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): StringSchema<T>;
+    min(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): StringSchema<T>;
+    max(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): StringSchema<T>;
+
+    email(message?: TestOptionsMessage): StringSchema<T>;
+    url(message?: TestOptionsMessage): StringSchema<T>;
+    trim(message?: TestOptionsMessage): StringSchema<T>;
+    lowercase(message?: TestOptionsMessage): StringSchema<T>;
+    uppercase(message?: TestOptionsMessage): StringSchema<T>;
+
+    ensure(): StringSchema<T>;
+    matches(
+      regex: RegExp,
+      messageOrOptions?:
+        | TestOptionsMessage
+        | {
+        message?: TestOptionsMessage,
+        excludeEmptyString?: boolean,
+        ...
+      }
+    ): StringSchema<T>;
+
+    nullable(isNullable?: true): StringSchema<?T>;
+    nullable(isNullable: false): StringSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): StringSchema<$NonMaybeType<T>>;
+    notRequired(): StringSchema<?T>;
+  }
+
+  declare export default StringSchemaConstructor;
+}
+declare module 'yup/lib/number' {
+  import type Ref from 'yup/lib/Reference';
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type NumberSchemaConstructor = Class<NumberSchema<number>> &
+    (() => NumberSchema<number>);
+
+  declare export type GetterNumberSchema = <T>(T) => NumberSchema<T>;
+
+  declare export interface NumberSchema<T>
+    extends Schema<T, GetterNumberSchema> {
+    lessThan(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): NumberSchema<T>;
+    moreThan(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): NumberSchema<T>;
+    min(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): NumberSchema<T>;
+    max(
+      limit: number | Ref<any>,
+      message?: TestOptionsMessage
+    ): NumberSchema<T>;
+    positive(message?: TestOptionsMessage): NumberSchema<T>;
+    negative(message?: TestOptionsMessage): NumberSchema<T>;
+    integer(message?: TestOptionsMessage): NumberSchema<T>;
+    round(type: 'floor' | 'ceil' | 'trunc' | 'round'): NumberSchema<T>;
+    truncate(): NumberSchema<T>;
+
+    nullable(isNullable?: true): NumberSchema<?T>;
+    nullable(isNullable: false): NumberSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): NumberSchema<$NonMaybeType<T>>;
+    notRequired(): NumberSchema<?T>;
+  }
+
+  declare export default NumberSchemaConstructor;
+}
+declare module 'yup/lib/boolean' {
+  import type { BooleanSchemaConstructor } from 'yup/lib/bool';
+  declare export default BooleanSchemaConstructor;
+}
+declare module 'yup/lib/bool' {
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type BooleanSchemaConstructor = Class<BooleanSchema<boolean>> &
+    (() => BooleanSchema<boolean>);
+
+  declare export type GetterBooleanSchema = <T>(T) => BooleanSchema<T>;
+
+  declare export interface BooleanSchema<T>
+    extends Schema<T, GetterBooleanSchema> {
+    nullable(isNullable?: true): BooleanSchema<?T>;
+    nullable(isNullable: false): BooleanSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): BooleanSchema<$NonMaybeType<T>>;
+    notRequired(): BooleanSchema<?T>;
+  }
+
+  declare export default BooleanSchemaConstructor;
+}
+declare module 'yup/lib/date' {
+  import type Ref from 'yup/lib/Reference';
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type DateSchemaConstructor = Class<DateSchema<Date>> &
+    (() => DateSchema<Date>);
+
+  declare export type GetterDateSchema = <T>(T) => DateSchema<T>;
+
+  declare export interface DateSchema<T> extends Schema<T, GetterDateSchema> {
+    min(
+      limit: Date | string | Ref<any>,
+      message?: TestOptionsMessage
+    ): DateSchema<T>;
+    max(
+      limit: Date | string | Ref<any>,
+      message?: TestOptionsMessage
+    ): DateSchema<T>;
+
+    nullable(isNullable?: true): DateSchema<?T>;
+    nullable(isNullable: false): DateSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): DateSchema<$NonMaybeType<T>>;
+    notRequired(): DateSchema<?T>;
+  }
+
+  declare export default DateSchemaConstructor;
+}
+declare module 'yup/lib/array' {
+  import type Ref from 'yup/lib/Reference';
+  import type { Schema, TestOptionsMessage } from 'yup';
+
+  declare export type ArraySchemaConstructor = Class<ArraySchema<Array<any>>> &
+    (<T>() => ArraySchema<Array<T>>) &
+    (<U>(type: Schema<U>) => ArraySchema<Array<U>>);
+
+  declare export type GetterArraySchema = <T>(T) => ArraySchema<T>;
+
+  declare export interface ArraySchema<T> extends Schema<T, GetterArraySchema> {
+    of<U>(type: Schema<U, any>): ArraySchema<Array<U>>;
+    min(limit: number | Ref<any>, message?: TestOptionsMessage): ArraySchema<T>;
+    max(limit: number | Ref<any>, message?: TestOptionsMessage): ArraySchema<T>;
+    ensure(): ArraySchema<T>;
+    compact(
+      rejector?: (value: any, index: number, array: Array<T>) => boolean
+    ): ArraySchema<T>;
+    nullable(isNullable?: true): ArraySchema<?T>;
+    nullable(isNullable: false): ArraySchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): ArraySchema<$NonMaybeType<T>>;
+    notRequired(): ArraySchema<?T>;
+  }
+
+  declare export default ArraySchemaConstructor;
+}
+declare module 'yup/lib/object' {
+  import type { BaseSchema, Schema, TestOptionsMessage } from 'yup';
+
+  declare export type ExtractSchemaType = <V>(v: BaseSchema<V, any>) => V;
+
+  declare export type ObjectSchemaConstructor = Class<ObjectSchema<{...}>> &
+    (() => ObjectSchema<{...}>) &
+    (<U>(obj: U) => ObjectSchema<$ObjMap<U, ExtractSchemaType>>);
+
+  declare export type GetterObjectSchema = <T>(T) => ObjectSchema<T>;
+
+  declare export interface ObjectSchema<T>
+    extends Schema<T, GetterObjectSchema> {
+    shape<U>(
+      fields: U,
+      noSortEdges?: Array<[string, string]>
+    ): ObjectSchema<$ObjMap<U, ExtractSchemaType> & T>;
+
+    from<From, To>(
+      fromKey: From,
+      toKey: To,
+      alias: true
+    ): ObjectSchema<T & { [To]: $ElementType<T, From>, ... }>;
+
+    /*
+     * No ability to describe returned Schema type in this case
+     *
+     * Use own type `R` for describe `ObjectSchema<R>`, Example:
+     *
+     * object({a: string()}).from<{a2: string}>('a','a2')
+     */
+    from<R>(fromKey: string, toKey: string, alias?: false): ObjectSchema<R>;
+
+    noUnknown(
+      onlyKnownKeys?: boolean,
+      message?: TestOptionsMessage
+    ): ObjectSchema<T>;
+
+    /*
+     * No ability to describe type for `camelCase()` and `constantCase()`
+     *
+     * Use own type `R` for describe `ObjectSchema<R>`, Example:
+     *
+     * object({a_aa_a: string()}).camelCase<{aAaA: string}>()
+     *
+     * object({a_aa_a: string()}).constantCase<{A_AA_A: string}>()
+     * */
+    camelCase<R>(): ObjectSchema<R>;
+    constantCase<R>(): ObjectSchema<R>;
+
+    nullable(isNullable?: true): ObjectSchema<?T>;
+    nullable(isNullable: false): ObjectSchema<$NonMaybeType<T>>;
+    required(message?: TestOptionsMessage): ObjectSchema<$NonMaybeType<T>>;
+    notRequired(): ObjectSchema<?T>;
+  }
+
+  declare export default ObjectSchemaConstructor;
+}
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_middleware.js b/definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_middleware.js
similarity index 100%
rename from definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_middleware.js
rename to definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_middleware.js
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_shallow.js b/definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_shallow.js
similarity index 100%
rename from definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_shallow.js
rename to definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_shallow.js
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_zustand.js b/definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_zustand.js
similarity index 100%
rename from definitions/npm/zustand_v1.x.x/flow_v0.84.x-/test_zustand.js
rename to definitions/npm/zustand_v1.x.x/flow_v0.201.x-/test_zustand.js
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-/zustand_v1.x.x.js b/definitions/npm/zustand_v1.x.x/flow_v0.201.x-/zustand_v1.x.x.js
similarity index 100%
rename from definitions/npm/zustand_v1.x.x/flow_v0.84.x-/zustand_v1.x.x.js
rename to definitions/npm/zustand_v1.x.x/flow_v0.201.x-/zustand_v1.x.x.js
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_middleware.js b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_middleware.js
new file mode 100644
index 0000000000..de34422775
--- /dev/null
+++ b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_middleware.js
@@ -0,0 +1,31 @@
+// @flow strict
+import { describe, it } from 'flow-typed-test';
+import create from 'zustand';
+import { redux, devtools } from 'zustand/middleware';
+
+describe('zustand middleware', () => {
+  it('works', () => {
+    const types = { increase: 'INCREASE', decrease: 'DECREASE' };
+
+    const reducer = (state, { type, by = 1 }) => {
+      switch (type) {
+        case types.increase:
+          return { count: state.count + by };
+        case types.decrease:
+          return { count: state.count - by };
+      }
+    };
+
+    const initialState = { count: 0 };
+
+    const [useStore1] = create(redux(reducer, initialState));
+
+    const [useStore2] = create(
+      devtools(set => ({
+        count: 0,
+        increment: () => set(state => ({ count: state.count + 1 })),
+      }))
+    );
+    const [useStore3] = create(devtools(redux(reducer, initialState)));
+  });
+});
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_shallow.js b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_shallow.js
new file mode 100644
index 0000000000..d115dbbb43
--- /dev/null
+++ b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_shallow.js
@@ -0,0 +1,15 @@
+// @flow strict
+import { describe, it } from 'flow-typed-test';
+import shallow, { shallow as namedShallow } from 'zustand/shallow';
+
+describe('zustand shallow', () => {
+  it('works', () => {
+    (shallow({ a: 1 }, { b: 2 }): boolean);
+    (namedShallow({ a: 1 }, { b: 2 }): boolean);
+
+    // $FlowExpectedError
+    (shallow({ a: 1 }, { b: 2 }): string);
+    // $FlowExpectedError
+    (namedShallow({ a: 1 }, { b: 2 }): number);
+  });
+});
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_zustand.js b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_zustand.js
new file mode 100644
index 0000000000..de1ef74fc5
--- /dev/null
+++ b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/test_zustand.js
@@ -0,0 +1,55 @@
+// @flow strict
+import { describe, it } from 'flow-typed-test';
+import create from 'zustand';
+import shallow from 'zustand/shallow';
+
+describe('zustand', () => {
+  it('supports basic use', () => {
+    const [useStore] = create(set => ({
+      count: 0,
+      increase: () => set(state => ({ count: state.count + 1 })),
+      reset: () => set({ count: 0 }),
+    }));
+
+    function Counter() {
+      const count: number = useStore(state => state.count);
+    }
+
+    function Controls() {
+      const increase: () => void = useStore(state => state.increase);
+    }
+  });
+
+  it('supports equality fn', () => {
+    const [useStore] = create(set => ({
+      foo: 1,
+      bar: 'baz',
+    }));
+
+    const { foo, bar } = useStore(
+      state => ({ foo: state.foo, bar: state.bar }),
+      shallow
+    );
+
+    (foo: number);
+    (bar: string);
+  });
+
+  it('supports api', () => {
+    const [, api] = create(() => ({ a: 1, b: 2, c: 3 }));
+
+    const num: number = api.getState().a;
+    // $FlowExpectedError
+    const num: string = api.getState().b;
+    const unsub1 = api.subscribe(state => console.log('state changed', state));
+    const unsub2 = api.subscribe(a => console.log('a changed', a), {
+      selector: state => state.a,
+    });
+    api.setState({ a: 1 });
+    unsub1();
+    unsub2();
+    // $FlowExpectedError
+    api.setState({ b: [] });
+    api.destroy();
+  });
+});
diff --git a/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/zustand_v1.x.x.js b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/zustand_v1.x.x.js
new file mode 100644
index 0000000000..6561440bdd
--- /dev/null
+++ b/definitions/npm/zustand_v1.x.x/flow_v0.84.x-v0.200.x/zustand_v1.x.x.js
@@ -0,0 +1,60 @@
+declare module 'zustand' {
+  // https://github.com/react-spring/zustand/blob/410631045f32b23268fcef7ce865aacc503fe955/src/index.ts
+
+  declare type State = { ... };
+  declare type StateListener<T> = (state: T) => void;
+  declare type StateSelector<T: State, U> = (state: T) => U;
+  declare type PartialState<T: State> = $Shape<T> | ((state: T) => $Shape<T>);
+  declare type EqualityChecker<T> = (state: T, newState: any) => boolean;
+  declare type SubscribeOptions<T: State, U> = {|
+    selector?: StateSelector<T, U>,
+    equalityFn?: EqualityChecker<U>,
+    currentSlice?: U,
+    subscribeError?: Error,
+  |};
+  declare type SetState<T: State> = (partial: PartialState<T>) => void;
+  declare type GetState<T: State> = () => T;
+  declare type Subscribe<T: State> = <U>(
+    listener: StateListener<U | void>,
+    options?: SubscribeOptions<T, U>
+  ) => () => void;
+  declare type Destroy = () => void;
+
+  declare type UseStore<T: State> = <U>(
+    selector?: StateSelector<T, U>,
+    equalityFn?: EqualityChecker<U>
+  ) => U;
+  declare type StoreApi<T: State> = {|
+    setState: SetState<T>,
+    getState: GetState<T>,
+    subscribe: Subscribe<T>,
+    destroy: Destroy,
+  |};
+  declare type StateCreator<T: State> = (
+    set: SetState<T>,
+    get: GetState<T>,
+    api: StoreApi<T>
+  ) => T;
+
+  declare function create<TState: State>(
+    createState: StateCreator<TState>
+  ): [UseStore<TState>, StoreApi<TState>];
+
+  declare export default typeof create;
+}
+
+declare module 'zustand/middleware' {
+  declare export function redux(
+    reducer: any,
+    initial: any
+  ): (set: any, get: any, api: any) => any;
+  declare export function devtools(
+    fn: any,
+    prefix?: any
+  ): (set: any, get: any, api: any) => any;
+}
+
+declare module 'zustand/shallow' {
+  declare export function shallow(a: mixed, b: mixed): boolean;
+  declare export default typeof shallow;
+}