# Flow

> Upgrading to [Types-First](../../lang/types-first) mode may require a substantial

## Pages

- [Flow Annotate-Exports](cli-annotate-exports.md): Upgrading to [Types-First](../../lang/types-first) mode may require a substantial
- [Flow Coverage](cli-coverage.md): The coverage command provides a metric of the amount of checking that Flow has
- [Flow CLI](cli.md): The flow command line tool is made to be easy-to-use for simple cases.
- [.flowconfig [declarations]](config-declarations.md): Often third-party libraries have broken type definitions or have type
- [.flowconfig [ignore]](config-ignore.md): The`[ignore]`section in a`.flowconfig`file tells Flow to ignore files
- [.flowconfig [include]](config-include.md): The`[include]`section in a`.flowconfig`file tells Flow to include the
- [.flowconfig](config.md): Every Flow project contains a`.flowconfig`file. You can configure Flow by
- [.flowconfig [libs]](config-libs.md): The`[libs]`section in a`.flowconfig`file tells Flow to include the
- [.flowconfig [lints]](config-lints.md): The`[lints]`section in a`.flowconfig`file can contain several key-value
- [.flowconfig [options]](config-options.md): import {SinceVersion, UntilVersion} from '../../components/VersionTags';
- [.flowconfig [untyped]](config-untyped.md): The`[untyped]`section in a`.flowconfig`file tells Flow to not typecheck files
- [.flowconfig [version]](config-version.md): You can specify in the`.flowconfig`which version of Flow you expect to use.
- [Declaration Files](declarations.md): Let's look at a more general, and sometimes more convenient way to
- [Emacs](editors-emacs.md): You can add support for Flow in Emacs by using [flow-for-emacs](https://github.com/flowtype/flow-for-emacs)
- [Editors](editors.md): You can benefit from having Flow run as you develop by integrating into your editor.
- [Sublime Text](editors-sublime-text.md): * Install the Package Control plugin if you don't have it
- [Vim](editors-vim.md): Flow's editor integration is primarily via the [Language Server Protocol](https://microsoft.github.io/language-server...
- [Visual Studio Code](editors-vscode.md): Support for Flow in [Visual Studio Code](https://code.visualstudio.com/) is provided by
- [WebStorm](editors-webstorm.md): Webstorm installation instructions can be found here:
- [Defining enums](enums-defining-enums.md): import {SinceVersion} from '../../components/VersionTags';
- [Enabling enums in your project](enums-enabling-enums.md): To enable Flow Enums in your repo, you must first update the following packages:
- [Flow Enums](enums.md): Flow Enums define a fixed set of constants which create their own type.
- [Migrating from legacy patterns](enums-migrating-legacy-patterns.md): Learn how to migrate to Flow Enums from legacy JavaScript enum patterns like`Object.freeze`.
- [Using enums](enums-using-enums.md): import {SinceVersion} from '../../components/VersionTags';
- [Error Suppressions](errors.md): import {SinceVersion, UntilVersion} from '../../components/VersionTags';
- [FAQ](faq.md): Flow does not keep track of side effects, so any function call may potentially nullify your check.
- [Getting Started](getting-started.md): Flow is a static type checker for your JavaScript code. It does a lot of work
- [Documentation](index.md): Guides and references for all you need to know about Flow.
- [Installation](install.md): import Tabs from '@theme/Tabs';
- [Annotation Requirement](lang-annotation-requirement.md): **Note:** As of version 0.199 Flow uses [Local Type Inference](https://medium.com/flow-type/local-type-inference-for-...
- [Depth Subtyping](lang-depth-subtyping.md): Assume we have two [classes](../../types/classes), which have a subtype relationship using`extends`:
- [Lazy Mode](lang-lazy-modes.md): By default, the Flow server will typecheck all your code. This way it can answer
- [Nominal & Structural Typing](lang-nominal-structural.md): A static type checker can use either the name (nominal typing) or the structure (structural typing)
- [Type Refinements](lang-refinements.md): Refinements allow us to narrow the type of a value based on conditional tests.
- [Subsets & Subtypes](lang-subtypes.md): A type like`number`,`boolean`, or`string`describes a set of possible
- [Type Hierarchy](lang-type-hierarchy.md): Types in Flow form a hierarchy based on [subtyping](../subtypes):
- [Types & Expressions](lang-types-and-expressions.md): In JavaScript there are many types of values: numbers, strings, booleans,
- [File Signatures (Types-First)](lang-types-first.md): Flow checks codebases by processing each file separately in dependency
- [Variable Declarations](lang-variables.md): import {SinceVersion} from '../../components/VersionTags';
- [Type Variance](lang-variance.md): Variance is a topic that comes up fairly often in type systems. It is used to determine
- [Width Subtyping](lang-width-subtyping.md): It's safe to use an object with "extra" properties in a position that is
- [Creating Library Definitions](libdefs-creation.md): import {SinceVersion} from '../../components/VersionTags';
- [Library Definitions](libdefs.md): Most real JavaScript programs depend on third-party code and not just code
- [Flowlint Comments](linting-flowlint-comments.md): You can use`flowlint`comments to specify more granular lint settings within a file.
- [Linting Overview](linting.md): Flow contains a linting framework that can tell you about more than just type errors. This framework is highly config...
- [Lint Rule Reference](linting-rule-reference.md): While`all`isn't technically a lint rule, it's worth mentioning here.`all`sets the default
- [Match Expressions and Statements](match.md): *An experimental Flow language feature. See adoption for how to enable.*
- [Migration from existing patterns](match-migration.md): You can turn a`switch`into either a match statement or a match expression, depending on its usage.
- [Match Patterns](match-patterns.md): Match patterns both define a condition that must be matched, and new variables that are extracted (like destructuring).
- [Component Syntax](react-component-syntax.md): [Components](https://react.dev/learn/your-first-component) are the foundation for building UIs in React. While compon...
- [Component Types](react-component-types.md): :::info
- [Event Handling](react-events.md): The [React docs for handling events](https://react.dev/learn/responding-to-events) show how an event handler can be a...
- [Function/Class Components](react-function-and-class-components.md): Adding Flow types to your [React components](https://react.dev/learn/your-first-component) is incredibly powerful. Af...
- [Higher-order Components](react-hoc.md): :::danger
- [Hook Syntax](react-hook-syntax.md): Hook Syntax is first-class syntax and typechecking support for React hooks, bringing hooks into
- [Getting Started](react.md): Developers will often use Flow and React together, so it is important that Flow
- [Multi-platform Support for React Native](react-multiplatform.md): :::caution
- [Ref Functions](react-refs.md): React allows you to grab the instance of an element or component with [refs](https://react.dev/learn/manipulating-the...
- [Render Types](react-render-types.md): Some component libraries or design systems may want to restrict how components may be composed.
- [Type Reference](react-types.md): import {SinceVersion, UntilVersion} from '../../components/VersionTags';
- [Flow Strict](strict.md): You can enable stronger safety guarantees in Flow (such as banning`any`/`Object`/`Function`types and requiring all ...
- [Babel](tools-babel.md): Flow and [Babel](http://babeljs.io/) are designed to work great together. It
- [ESLint](tools-eslint.md): ESLint is a static analysis tool which can help you quickly find and
- [flow-remove-types](tools-flow-remove-types.md): [`flow-remove-types`](https://github.com/facebook/flow/tree/master/packages/flow-remove-types) is a small
- [Tools](tools.md): import DocCardList from '@theme/DocCardList';
- [Prettier](tools-prettier.md): All Flow features are supported by [Prettier](https://prettier.io/).
- [Type Aliases](types-aliases.md): When you have complicated types that you want to reuse in multiple places, you
- [Any](types-any.md): **Warning:** Do not mistake`any`with [`unknown`](../unknown). It's also not the same as [`empty`](../empty).
- [Arrays](types-arrays.md): import {SinceVersion} from '../../components/VersionTags';
- [Type Casting Expressions](types-casting.md): Sometimes it is useful to assert a type without using something like a function
- [Classes](types-classes.md): JavaScript [classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes)
- [Comment Types](types-comments.md): Flow supports a comment-based syntax, which makes it possible to use Flow
- [Conditional Types](types-conditional.md): Flow's conditional type allows you to conditionally choose between two different output types by inspecting an input ...
- [Const Expressions](types-const-expression.md): import {SinceVersion} from '../../components/VersionTags';
- [Empty](types-empty.md): The`empty`type has no values. It is the [subtype of all other types](../../lang/type-hierarchy) (i.e. the [bottom t...
- [Functions](types-functions.md): Functions have two places where types are applied: parameters (input) and the return value (output).
- [Generators](types-generators.md)
- [Generics](types-generics.md): Generics (sometimes referred to as polymorphic types) are a way of abstracting
- [Type Annotations](types.md): Adding type annotations is an important part of your interaction with Flow.
- [Indexed Access Types](types-indexed-access.md): Flow’s Indexed Access Types allow you to get the type of a property from an [object](../objects), [array](../arrays),...
- [Interfaces](types-interfaces.md): [Classes](../classes) in Flow are [nominally typed](../../lang/nominal-structural). This means that when you have two...
- [Intersections](types-intersections.md): Sometimes it is useful to create a type which is ***all of*** a set of other
- [Literal Types](types-literals.md): Flow has [primitive types](../primitives) for
- [Mapped Types](types-mapped-types.md): import {SinceVersion} from '../../components/VersionTags';
- [Maybe Types](types-maybe.md): You can prefix a type with`?`to make it a [union](../unions) with`null`and`void`:
- [Mixed](types-mixed.md): import {SinceVersion} from '../../components/VersionTags';
- [Module Types](types-modules.md): It is often useful to share types between modules (files).
- [Objects](types-objects.md): Objects can be used in many different ways in JavaScript.
- [Opaque Type Aliases](types-opaque-types.md): Opaque type aliases are type aliases that do not allow access to their
- [Primitive Types](types-primitives.md): JavaScript has a number of different primitive types
- [Tuples](types-tuples.md): Tuple types represent a **fixed length** list, where the elements can have **different types**.
- [Type Guards](types-type-guards.md): Flow lets you define functions whose return expression encodes some type predicate over a parameter`param`. This pre...
- [Typeof Types](types-typeof.md): JavaScript has a`typeof`operator which returns a string describing a value.
- [Unions](types-unions.md): import {SinceVersion} from '../../components/VersionTags';
- [Unknown](types-unknown.md): import {SinceVersion} from '../../components/VersionTags';
- [Utility Types](types-utilities.md): import {SinceVersion, UntilVersion} from '../../components/VersionTags';
- [Usage](usage.md): Once you have [installed](../install/) Flow, you will want to get a feel of how to use Flow at the most basic level. ...