Module Flow_ast.Statement

module Block: { ... };
module If: { ... };
module Labeled: { ... };
module Break: { ... };
module Continue: { ... };
module Debugger: { ... };
module With: { ... };
module TypeAlias: { ... };
module OpaqueType: { ... };
type match_statement('M, 'T) = Match.t('M, 'T, Statement.t('M, 'T));
let pp_match_statement: (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => Format.formatter => match_statement('M, 'T) => unit;
let show_match_statement: (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => match_statement('M, 'T) => string;
module Switch: { ... };
module Return: { ... };
module Throw: { ... };
module Try: { ... };
module VariableDeclaration: { ... };
module While: { ... };
module DoWhile: { ... };
module For: { ... };
module ForIn: { ... };
module ForOf: { ... };
module EnumDeclaration: { ... };
module ComponentDeclaration: { ... };
module Interface: { ... };
module DeclareClass: { ... };
module DeclareComponent: { ... };
module DeclareVariable: { ... };
module DeclareFunction: { ... };
module DeclareModule: { ... };
module DeclareModuleExports: { ... };
module DeclareNamespace: { ... };
module ExportNamedDeclaration: { ... };
module ExportDefaultDeclaration: { ... };
module DeclareExportDeclaration: { ... };
module ImportDeclaration: { ... };
module Expression: { ... };
module Empty: { ... };
type export_kind =
  1. | ExportType
  2. | ExportValue
;
and t('M, 'T) = ('M, t'('M, 'T));
and t'('M, 'T) =
  1. | Block(Block.t('M, 'T))
  2. | Break(Break.t('M))
  3. | ClassDeclaration(Class.t('M, 'T))
  4. | ComponentDeclaration(ComponentDeclaration.t('M, 'T))
  5. | Continue(Continue.t('M))
  6. | Debugger(Debugger.t('M))
  7. | DeclareClass(DeclareClass.t('M, 'T))
  8. | DeclareComponent(DeclareComponent.t('M, 'T))
  9. | DeclareEnum(EnumDeclaration.t('M, 'T))
  10. | DeclareExportDeclaration(DeclareExportDeclaration.t('M, 'T))
  11. | DeclareFunction(DeclareFunction.t('M, 'T))
  12. | DeclareInterface(Interface.t('M, 'T))
  13. | DeclareModule(DeclareModule.t('M, 'T))
  14. | DeclareModuleExports(DeclareModuleExports.t('M, 'T))
  15. | DeclareNamespace(DeclareNamespace.t('M, 'T))
  16. | DeclareTypeAlias(TypeAlias.t('M, 'T))
  17. | DeclareOpaqueType(OpaqueType.t('M, 'T))
  18. | DeclareVariable(DeclareVariable.t('M, 'T))
  19. | DoWhile(DoWhile.t('M, 'T))
  20. | Empty(Empty.t('M))
  21. | EnumDeclaration(EnumDeclaration.t('M, 'T))
  22. | ExportDefaultDeclaration(ExportDefaultDeclaration.t('M, 'T))
  23. | ExportNamedDeclaration(ExportNamedDeclaration.t('M, 'T))
  24. | Expression(Expression.t('M, 'T))
  25. | For(For.t('M, 'T))
  26. | ForIn(ForIn.t('M, 'T))
  27. | ForOf(ForOf.t('M, 'T))
  28. | FunctionDeclaration(Function.t('M, 'T))
  29. | If(If.t('M, 'T))
  30. | ImportDeclaration(ImportDeclaration.t('M, 'T))
  31. | InterfaceDeclaration(Interface.t('M, 'T))
  32. | Labeled(Labeled.t('M, 'T))
  33. | Match(match_statement('M, 'T))
  34. | Return(Return.t('M, 'T))
  35. | Switch(Switch.t('M, 'T))
  36. | Throw(Throw.t('M, 'T))
  37. | Try(Try.t('M, 'T))
  38. | TypeAlias(TypeAlias.t('M, 'T))
  39. | OpaqueType(OpaqueType.t('M, 'T))
  40. | VariableDeclaration(VariableDeclaration.t('M, 'T))
  41. | While(While.t('M, 'T))
  42. | With(With.t('M, 'T))
;
let pp_export_kind: Format.formatter => export_kind => unit;
let show_export_kind: export_kind => string;
let pp: (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => Format.formatter => t('M, 'T) => unit;
let show: (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => t('M, 'T) => string;
let pp_t': (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => Format.formatter => t'('M, 'T) => unit;
let show_t': (Format.formatter => 'M => unit) => (Format.formatter => 'T => unit) => t'('M, 'T) => string;