Module `Flow_ast.Type`

module Function: { ... };

module Generic: { ... };

module IndexedAccess: { ... };

module OptionalIndexedAccess: { ... };

module Object: { ... };

module Interface: { ... };

module Nullable: { ... };

module Typeof: { ... };

module Tuple: { ... };

module Array: { ... };

module Union: { ... };

module Intersection: { ... };

type t('M, 'T) = ('T, t'('M, 'T));

and t'('M, 'T) =

| Any(option(Syntax.t('M, unit)))
| Mixed(option(Syntax.t('M, unit)))
| Empty(option(Syntax.t('M, unit)))
| Void(option(Syntax.t('M, unit)))
| Null(option(Syntax.t('M, unit)))
| Number(option(Syntax.t('M, unit)))
| BigInt(option(Syntax.t('M, unit)))
| String(option(Syntax.t('M, unit)))
| Boolean(option(Syntax.t('M, unit)))
| Symbol(option(Syntax.t('M, unit)))
| Exists(option(Syntax.t('M, unit)))
| Nullable(Nullable.t('M, 'T))
| Function(Function.t('M, 'T))
| Object(Object.t('M, 'T))
| Interface(Interface.t('M, 'T))
| Array(Array.t('M, 'T))
| Generic(Generic.t('M, 'T))
| IndexedAccess(IndexedAccess.t('M, 'T))
| OptionalIndexedAccess(OptionalIndexedAccess.t('M, 'T))
| Union(Union.t('M, 'T))
| Intersection(Intersection.t('M, 'T))
| Typeof(Typeof.t('M, 'T))
| Tuple(Tuple.t('M, 'T))
| StringLiteral(StringLiteral.t('M))
| NumberLiteral(NumberLiteral.t('M))
| BigIntLiteral(BigIntLiteral.t('M))
| BooleanLiteral(BooleanLiteral.t('M))

;

and annotation('M, 'T) = ('M, t('M, 'T));

and annotation_or_hint('M, 'T) =

| Missing('T)
| Available(annotation('M, 'T))

;

module TypeParam: { ... };

module TypeParams: { ... };

module TypeArgs: { ... };

module Predicate: { ... };