hermes-transform 0.9.0 → 0.10.0

package/dist/generated/node-types.js.flow

@@ -6,6 +6,13 @@
  *
  * @flow strict-local
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
@@ -24,6 +31,7 @@ import type {
   AssignmentPattern as AssignmentPatternType,
   AwaitExpression as AwaitExpressionType,
   BigIntLiteralTypeAnnotation as BigIntLiteralTypeAnnotationType,
+  BigIntTypeAnnotation as BigIntTypeAnnotationType,
   BinaryExpression as BinaryExpressionType,
   BlockStatement as BlockStatementType,
   BooleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotationType,
@@ -41,8 +49,6 @@ import type {
   DeclareClass as DeclareClassType,
   DeclaredPredicate as DeclaredPredicateType,
   DeclareExportAllDeclaration as DeclareExportAllDeclarationType,
-  DeclareExportDeclaration as DeclareExportDeclarationType,
-  DeclareFunction as DeclareFunctionType,
   DeclareInterface as DeclareInterfaceType,
   DeclareModule as DeclareModuleType,
   DeclareModuleExports as DeclareModuleExportsType,
@@ -64,7 +70,6 @@ import type {
   ExistsTypeAnnotation as ExistsTypeAnnotationType,
   ExportAllDeclaration as ExportAllDeclarationType,
   ExportDefaultDeclaration as ExportDefaultDeclarationType,
-  ExportNamedDeclaration as ExportNamedDeclarationType,
   ExportSpecifier as ExportSpecifierType,
   ExpressionStatement as ExpressionStatementType,
   ForInStatement as ForInStatementType,
@@ -120,7 +125,6 @@ import type {
   ObjectTypeCallProperty as ObjectTypeCallPropertyType,
   ObjectTypeIndexer as ObjectTypeIndexerType,
   ObjectTypeInternalSlot as ObjectTypeInternalSlotType,
-  ObjectTypeProperty as ObjectTypePropertyType,
   ObjectTypeSpreadProperty as ObjectTypeSpreadPropertyType,
   OpaqueType as OpaqueTypeType,
   OptionalIndexedAccessType as OptionalIndexedAccessTypeType,
@@ -210,6 +214,8 @@ export type BigIntLiteralTypeAnnotationProps = {
   +raw: BigIntLiteralTypeAnnotationType['raw'],
 };
 
+export type BigIntTypeAnnotationProps = {};
+
 export type BinaryExpressionProps = {
   +left: MaybeDetachedNode<BinaryExpressionType['left']>,
   +right: MaybeDetachedNode<BinaryExpressionType['right']>,
@@ -308,22 +314,6 @@ export type DeclareExportAllDeclarationProps = {
   +source: MaybeDetachedNode<DeclareExportAllDeclarationType['source']>,
 };
 
-export type DeclareExportDeclarationProps = {
-  +declaration?: ?MaybeDetachedNode<
-    DeclareExportDeclarationType['declaration'],
-  >,
-  +specifiers: $ReadOnlyArray<
-    MaybeDetachedNode<DeclareExportDeclarationType['specifiers'][number]>,
-  >,
-  +source?: ?MaybeDetachedNode<DeclareExportDeclarationType['source']>,
-  +default: DeclareExportDeclarationType['default'],
-};
-
-export type DeclareFunctionProps = {
-  +id: MaybeDetachedNode<DeclareFunctionType['id']>,
-  +predicate?: ?MaybeDetachedNode<DeclareFunctionType['predicate']>,
-};
-
 export type DeclareInterfaceProps = {
   +id: MaybeDetachedNode<DeclareInterfaceType['id']>,
   +typeParameters?: ?MaybeDetachedNode<DeclareInterfaceType['typeParameters']>,
@@ -438,15 +428,6 @@ export type ExportDefaultDeclarationProps = {
   +declaration: MaybeDetachedNode<ExportDefaultDeclarationType['declaration']>,
 };
 
-export type ExportNamedDeclarationProps = {
-  +declaration?: ?MaybeDetachedNode<ExportNamedDeclarationType['declaration']>,
-  +specifiers: $ReadOnlyArray<
-    MaybeDetachedNode<ExportNamedDeclarationType['specifiers'][number]>,
-  >,
-  +source?: ?MaybeDetachedNode<ExportNamedDeclarationType['source']>,
-  +exportKind: ExportNamedDeclarationType['exportKind'],
-};
-
 export type ExportSpecifierProps = {
   +exported: MaybeDetachedNode<ExportSpecifierType['exported']>,
   +local: MaybeDetachedNode<ExportSpecifierType['local']>,
@@ -785,17 +766,6 @@ export type ObjectTypeInternalSlotProps = {
   +method: ObjectTypeInternalSlotType['method'],
 };
 
-export type ObjectTypePropertyProps = {
-  +key: MaybeDetachedNode<ObjectTypePropertyType['key']>,
-  +value: MaybeDetachedNode<ObjectTypePropertyType['value']>,
-  +method: ObjectTypePropertyType['method'],
-  +optional: ObjectTypePropertyType['optional'],
-  +static: ObjectTypePropertyType['static'],
-  +proto: ObjectTypePropertyType['proto'],
-  +variance?: ?MaybeDetachedNode<ObjectTypePropertyType['variance']>,
-  +kind: ObjectTypePropertyType['kind'],
-};
-
 export type ObjectTypeSpreadPropertyProps = {
   +argument: MaybeDetachedNode<ObjectTypeSpreadPropertyType['argument']>,
 };
@@ -837,6 +807,7 @@ export type PropertyDefinitionProps = {
   +typeAnnotation?: ?MaybeDetachedNode<
     PropertyDefinitionType['typeAnnotation'],
   >,
+  +tsModifiers?: ?MaybeDetachedNode<PropertyDefinitionType['tsModifiers']>,
 };
 
 export type QualifiedTypeIdentifierProps = {
@@ -1028,6 +999,7 @@ export function ArrayExpression(props: {
 }): DetachedNode<ArrayExpressionType> {
   const node = detachedProps<ArrayExpressionType>(props.parent, {
     type: 'ArrayExpression',
+    // $FlowFixMe[incompatible-call],
     elements: props.elements.map(n => asDetachedNode(n)),
     trailingComma: props.trailingComma,
   });
@@ -1041,7 +1013,9 @@ export function ArrayPattern(props: {
 }): DetachedNode<ArrayPatternType> {
   const node = detachedProps<ArrayPatternType>(props.parent, {
     type: 'ArrayPattern',
+    // $FlowFixMe[incompatible-call],
     elements: props.elements.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -1054,6 +1028,7 @@ export function ArrayTypeAnnotation(props: {
 }): DetachedNode<ArrayTypeAnnotationType> {
   const node = detachedProps<ArrayTypeAnnotationType>(props.parent, {
     type: 'ArrayTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     elementType: asDetachedNode(props.elementType),
   });
   setParentPointersInDirectChildren(node);
@@ -1067,7 +1042,9 @@ export function AssignmentExpression(props: {
   const node = detachedProps<AssignmentExpressionType>(props.parent, {
     type: 'AssignmentExpression',
     operator: props.operator,
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
@@ -1080,7 +1057,9 @@ export function AssignmentPattern(props: {
 }): DetachedNode<AssignmentPatternType> {
   const node = detachedProps<AssignmentPatternType>(props.parent, {
     type: 'AssignmentPattern',
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
@@ -1093,6 +1072,7 @@ export function AwaitExpression(props: {
 }): DetachedNode<AwaitExpressionType> {
   const node = detachedProps<AwaitExpressionType>(props.parent, {
     type: 'AwaitExpression',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -1111,13 +1091,25 @@ export function BigIntLiteralTypeAnnotation(props: {
   return node;
 }
 
+export function BigIntTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<BigIntTypeAnnotationType> {
+  return detachedProps<BigIntTypeAnnotationType>(props.parent, {
+    type: 'BigIntTypeAnnotation',
+  });
+}
+
 export function BinaryExpression(props: {
   ...$ReadOnly<BinaryExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<BinaryExpressionType> {
   const node = detachedProps<BinaryExpressionType>(props.parent, {
     type: 'BinaryExpression',
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
     operator: props.operator,
   });
@@ -1131,6 +1123,7 @@ export function BlockStatement(props: {
 }): DetachedNode<BlockStatementType> {
   const node = detachedProps<BlockStatementType>(props.parent, {
     type: 'BlockStatement',
+    // $FlowFixMe[incompatible-call],
     body: props.body.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -1166,6 +1159,7 @@ export function BreakStatement(props: {
 }): DetachedNode<BreakStatementType> {
   const node = detachedProps<BreakStatementType>(props.parent, {
     type: 'BreakStatement',
+    // $FlowFixMe[incompatible-call],
     label: asDetachedNode(props.label),
   });
   setParentPointersInDirectChildren(node);
@@ -1178,8 +1172,11 @@ export function CallExpression(props: {
 }): DetachedNode<CallExpressionType> {
   const node = detachedProps<CallExpressionType>(props.parent, {
     type: 'CallExpression',
+    // $FlowFixMe[incompatible-call],
     callee: asDetachedNode(props.callee),
+    // $FlowFixMe[incompatible-call],
     typeArguments: asDetachedNode(props.typeArguments),
+    // $FlowFixMe[incompatible-call],
     arguments: props.arguments.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -1192,7 +1189,9 @@ export function CatchClause(props: {
 }): DetachedNode<CatchClauseType> {
   const node = detachedProps<CatchClauseType>(props.parent, {
     type: 'CatchClause',
+    // $FlowFixMe[incompatible-call],
     param: asDetachedNode(props.param),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1205,6 +1204,7 @@ export function ChainExpression(props: {
 }): DetachedNode<ChainExpressionType> {
   const node = detachedProps<ChainExpressionType>(props.parent, {
     type: 'ChainExpression',
+    // $FlowFixMe[incompatible-call],
     expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
@@ -1217,6 +1217,7 @@ export function ClassBody(props: {
 }): DetachedNode<ClassBodyType> {
   const node = detachedProps<ClassBodyType>(props.parent, {
     type: 'ClassBody',
+    // $FlowFixMe[incompatible-call],
     body: props.body.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -1229,12 +1230,19 @@ export function ClassExpression(props: {
 }): DetachedNode<ClassExpressionType> {
   const node = detachedProps<ClassExpressionType>(props.parent, {
     type: 'ClassExpression',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     superClass: asDetachedNode(props.superClass),
+    // $FlowFixMe[incompatible-call],
     superTypeParameters: asDetachedNode(props.superTypeParameters),
+    // $FlowFixMe[incompatible-call],
     implements: props.implements.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     decorators: props.decorators.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1247,7 +1255,9 @@ export function ClassImplements(props: {
 }): DetachedNode<ClassImplementsType> {
   const node = detachedProps<ClassImplementsType>(props.parent, {
     type: 'ClassImplements',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
@@ -1260,8 +1270,11 @@ export function ConditionalExpression(props: {
 }): DetachedNode<ConditionalExpressionType> {
   const node = detachedProps<ConditionalExpressionType>(props.parent, {
     type: 'ConditionalExpression',
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
     alternate: asDetachedNode(props.alternate),
+    // $FlowFixMe[incompatible-call],
     consequent: asDetachedNode(props.consequent),
   });
   setParentPointersInDirectChildren(node);
@@ -1274,6 +1287,7 @@ export function ContinueStatement(props: {
 }): DetachedNode<ContinueStatementType> {
   const node = detachedProps<ContinueStatementType>(props.parent, {
     type: 'ContinueStatement',
+    // $FlowFixMe[incompatible-call],
     label: asDetachedNode(props.label),
   });
   setParentPointersInDirectChildren(node);
@@ -1296,11 +1310,17 @@ export function DeclareClass(props: {
 }): DetachedNode<DeclareClassType> {
   const node = detachedProps<DeclareClassType>(props.parent, {
     type: 'DeclareClass',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     extends: props.extends.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     implements: props.implements.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     mixins: props.mixins.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1313,6 +1333,7 @@ export function DeclaredPredicate(props: {
 }): DetachedNode<DeclaredPredicateType> {
   const node = detachedProps<DeclaredPredicateType>(props.parent, {
     type: 'DeclaredPredicate',
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
@@ -1325,49 +1346,26 @@ export function DeclareExportAllDeclaration(props: {
 }): DetachedNode<DeclareExportAllDeclarationType> {
   const node = detachedProps<DeclareExportAllDeclarationType>(props.parent, {
     type: 'DeclareExportAllDeclaration',
+    // $FlowFixMe[incompatible-call],
     source: asDetachedNode(props.source),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareExportDeclaration(props: {
-  ...$ReadOnly<DeclareExportDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<DeclareExportDeclarationType> {
-  const node = detachedProps<DeclareExportDeclarationType>(props.parent, {
-    type: 'DeclareExportDeclaration',
-    declaration: asDetachedNode(props.declaration),
-    specifiers: props.specifiers.map(n => asDetachedNode(n)),
-    source: asDetachedNode(props.source),
-    default: props.default,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function DeclareFunction(props: {
-  ...$ReadOnly<DeclareFunctionProps>,
-  +parent?: ESNode,
-}): DetachedNode<DeclareFunctionType> {
-  const node = detachedProps<DeclareFunctionType>(props.parent, {
-    type: 'DeclareFunction',
-    id: asDetachedNode(props.id),
-    predicate: asDetachedNode(props.predicate),
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function DeclareInterface(props: {
   ...$ReadOnly<DeclareInterfaceProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareInterfaceType> {
   const node = detachedProps<DeclareInterfaceType>(props.parent, {
     type: 'DeclareInterface',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     extends: props.extends.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1380,7 +1378,9 @@ export function DeclareModule(props: {
 }): DetachedNode<DeclareModuleType> {
   const node = detachedProps<DeclareModuleType>(props.parent, {
     type: 'DeclareModule',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
     kind: props.kind,
   });
@@ -1394,6 +1394,7 @@ export function DeclareModuleExports(props: {
 }): DetachedNode<DeclareModuleExportsType> {
   const node = detachedProps<DeclareModuleExportsType>(props.parent, {
     type: 'DeclareModuleExports',
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -1406,9 +1407,13 @@ export function DeclareOpaqueType(props: {
 }): DetachedNode<DeclareOpaqueTypeType> {
   const node = detachedProps<DeclareOpaqueTypeType>(props.parent, {
     type: 'DeclareOpaqueType',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     impltype: asDetachedNode(props.impltype),
+    // $FlowFixMe[incompatible-call],
     supertype: asDetachedNode(props.supertype),
   });
   setParentPointersInDirectChildren(node);
@@ -1421,8 +1426,11 @@ export function DeclareTypeAlias(props: {
 }): DetachedNode<DeclareTypeAliasType> {
   const node = detachedProps<DeclareTypeAliasType>(props.parent, {
     type: 'DeclareTypeAlias',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
@@ -1435,6 +1443,7 @@ export function DeclareVariable(props: {
 }): DetachedNode<DeclareVariableType> {
   const node = detachedProps<DeclareVariableType>(props.parent, {
     type: 'DeclareVariable',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
@@ -1447,7 +1456,9 @@ export function DoWhileStatement(props: {
 }): DetachedNode<DoWhileStatementType> {
   const node = detachedProps<DoWhileStatementType>(props.parent, {
     type: 'DoWhileStatement',
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
   });
   setParentPointersInDirectChildren(node);
@@ -1480,6 +1491,7 @@ export function EnumBooleanBody(props: {
 }): DetachedNode<EnumBooleanBodyType> {
   const node = detachedProps<EnumBooleanBodyType>(props.parent, {
     type: 'EnumBooleanBody',
+    // $FlowFixMe[incompatible-call],
     members: props.members.map(n => asDetachedNode(n)),
     explicitType: props.explicitType,
     hasUnknownMembers: props.hasUnknownMembers,
@@ -1494,7 +1506,9 @@ export function EnumBooleanMember(props: {
 }): DetachedNode<EnumBooleanMemberType> {
   const node = detachedProps<EnumBooleanMemberType>(props.parent, {
     type: 'EnumBooleanMember',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
@@ -1507,7 +1521,9 @@ export function EnumDeclaration(props: {
 }): DetachedNode<EnumDeclarationType> {
   const node = detachedProps<EnumDeclarationType>(props.parent, {
     type: 'EnumDeclaration',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1520,6 +1536,7 @@ export function EnumDefaultedMember(props: {
 }): DetachedNode<EnumDefaultedMemberType> {
   const node = detachedProps<EnumDefaultedMemberType>(props.parent, {
     type: 'EnumDefaultedMember',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
@@ -1532,6 +1549,7 @@ export function EnumNumberBody(props: {
 }): DetachedNode<EnumNumberBodyType> {
   const node = detachedProps<EnumNumberBodyType>(props.parent, {
     type: 'EnumNumberBody',
+    // $FlowFixMe[incompatible-call],
     members: props.members.map(n => asDetachedNode(n)),
     explicitType: props.explicitType,
     hasUnknownMembers: props.hasUnknownMembers,
@@ -1546,7 +1564,9 @@ export function EnumNumberMember(props: {
 }): DetachedNode<EnumNumberMemberType> {
   const node = detachedProps<EnumNumberMemberType>(props.parent, {
     type: 'EnumNumberMember',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
@@ -1559,6 +1579,7 @@ export function EnumStringBody(props: {
 }): DetachedNode<EnumStringBodyType> {
   const node = detachedProps<EnumStringBodyType>(props.parent, {
     type: 'EnumStringBody',
+    // $FlowFixMe[incompatible-call],
     members: props.members.map(n => asDetachedNode(n)),
     explicitType: props.explicitType,
     hasUnknownMembers: props.hasUnknownMembers,
@@ -1573,7 +1594,9 @@ export function EnumStringMember(props: {
 }): DetachedNode<EnumStringMemberType> {
   const node = detachedProps<EnumStringMemberType>(props.parent, {
     type: 'EnumStringMember',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
@@ -1586,6 +1609,7 @@ export function EnumSymbolBody(props: {
 }): DetachedNode<EnumSymbolBodyType> {
   const node = detachedProps<EnumSymbolBodyType>(props.parent, {
     type: 'EnumSymbolBody',
+    // $FlowFixMe[incompatible-call],
     members: props.members.map(n => asDetachedNode(n)),
     hasUnknownMembers: props.hasUnknownMembers,
   });
@@ -1609,7 +1633,9 @@ export function ExportAllDeclaration(props: {
 }): DetachedNode<ExportAllDeclarationType> {
   const node = detachedProps<ExportAllDeclarationType>(props.parent, {
     type: 'ExportAllDeclaration',
+    // $FlowFixMe[incompatible-call],
     exported: asDetachedNode(props.exported),
+    // $FlowFixMe[incompatible-call],
     source: asDetachedNode(props.source),
     exportKind: props.exportKind,
   });
@@ -1623,34 +1649,22 @@ export function ExportDefaultDeclaration(props: {
 }): DetachedNode<ExportDefaultDeclarationType> {
   const node = detachedProps<ExportDefaultDeclarationType>(props.parent, {
     type: 'ExportDefaultDeclaration',
+    // $FlowFixMe[incompatible-call],
     declaration: asDetachedNode(props.declaration),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ExportNamedDeclaration(props: {
-  ...$ReadOnly<ExportNamedDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<ExportNamedDeclarationType> {
-  const node = detachedProps<ExportNamedDeclarationType>(props.parent, {
-    type: 'ExportNamedDeclaration',
-    declaration: asDetachedNode(props.declaration),
-    specifiers: props.specifiers.map(n => asDetachedNode(n)),
-    source: asDetachedNode(props.source),
-    exportKind: props.exportKind,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ExportSpecifier(props: {
   ...$ReadOnly<ExportSpecifierProps>,
   +parent?: ESNode,
 }): DetachedNode<ExportSpecifierType> {
   const node = detachedProps<ExportSpecifierType>(props.parent, {
     type: 'ExportSpecifier',
+    // $FlowFixMe[incompatible-call],
     exported: asDetachedNode(props.exported),
+    // $FlowFixMe[incompatible-call],
     local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
@@ -1663,6 +1677,7 @@ export function ExpressionStatement(props: {
 }): DetachedNode<ExpressionStatementType> {
   const node = detachedProps<ExpressionStatementType>(props.parent, {
     type: 'ExpressionStatement',
+    // $FlowFixMe[incompatible-call],
     expression: asDetachedNode(props.expression),
     directive: props.directive,
   });
@@ -1676,8 +1691,11 @@ export function ForInStatement(props: {
 }): DetachedNode<ForInStatementType> {
   const node = detachedProps<ForInStatementType>(props.parent, {
     type: 'ForInStatement',
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1690,8 +1708,11 @@ export function ForOfStatement(props: {
 }): DetachedNode<ForOfStatementType> {
   const node = detachedProps<ForOfStatementType>(props.parent, {
     type: 'ForOfStatement',
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
     await: props.await,
   });
@@ -1705,9 +1726,13 @@ export function ForStatement(props: {
 }): DetachedNode<ForStatementType> {
   const node = detachedProps<ForStatementType>(props.parent, {
     type: 'ForStatement',
+    // $FlowFixMe[incompatible-call],
     init: asDetachedNode(props.init),
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
     update: asDetachedNode(props.update),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1720,11 +1745,17 @@ export function FunctionDeclaration(props: {
 }): DetachedNode<FunctionDeclarationType> {
   const node = detachedProps<FunctionDeclarationType>(props.parent, {
     type: 'FunctionDeclaration',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     params: props.params.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     returnType: asDetachedNode(props.returnType),
+    // $FlowFixMe[incompatible-call],
     predicate: asDetachedNode(props.predicate),
     generator: props.generator,
     async: props.async,
@@ -1739,11 +1770,17 @@ export function FunctionExpression(props: {
 }): DetachedNode<FunctionExpressionType> {
   const node = detachedProps<FunctionExpressionType>(props.parent, {
     type: 'FunctionExpression',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     params: props.params.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     returnType: asDetachedNode(props.returnType),
+    // $FlowFixMe[incompatible-call],
     predicate: asDetachedNode(props.predicate),
     generator: props.generator,
     async: props.async,
@@ -1758,10 +1795,15 @@ export function FunctionTypeAnnotation(props: {
 }): DetachedNode<FunctionTypeAnnotationType> {
   const node = detachedProps<FunctionTypeAnnotationType>(props.parent, {
     type: 'FunctionTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     params: props.params.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     this: asDetachedNode(props.this),
+    // $FlowFixMe[incompatible-call],
     returnType: asDetachedNode(props.returnType),
+    // $FlowFixMe[incompatible-call],
     rest: asDetachedNode(props.rest),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
@@ -1774,7 +1816,9 @@ export function FunctionTypeParam(props: {
 }): DetachedNode<FunctionTypeParamType> {
   const node = detachedProps<FunctionTypeParamType>(props.parent, {
     type: 'FunctionTypeParam',
+    // $FlowFixMe[incompatible-call],
     name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
     optional: props.optional,
   });
@@ -1788,7 +1832,9 @@ export function GenericTypeAnnotation(props: {
 }): DetachedNode<GenericTypeAnnotationType> {
   const node = detachedProps<GenericTypeAnnotationType>(props.parent, {
     type: 'GenericTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
@@ -1801,8 +1847,11 @@ export function IfStatement(props: {
 }): DetachedNode<IfStatementType> {
   const node = detachedProps<IfStatementType>(props.parent, {
     type: 'IfStatement',
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
     consequent: asDetachedNode(props.consequent),
+    // $FlowFixMe[incompatible-call],
     alternate: asDetachedNode(props.alternate),
   });
   setParentPointersInDirectChildren(node);
@@ -1815,7 +1864,9 @@ export function ImportAttribute(props: {
 }): DetachedNode<ImportAttributeType> {
   const node = detachedProps<ImportAttributeType>(props.parent, {
     type: 'ImportAttribute',
+    // $FlowFixMe[incompatible-call],
     key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
@@ -1828,8 +1879,11 @@ export function ImportDeclaration(props: {
 }): DetachedNode<ImportDeclarationType> {
   const node = detachedProps<ImportDeclarationType>(props.parent, {
     type: 'ImportDeclaration',
+    // $FlowFixMe[incompatible-call],
     specifiers: props.specifiers.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     source: asDetachedNode(props.source),
+    // $FlowFixMe[incompatible-call],
     assertions: props.assertions?.map(n => asDetachedNode(n)),
     importKind: props.importKind,
   });
@@ -1843,6 +1897,7 @@ export function ImportDefaultSpecifier(props: {
 }): DetachedNode<ImportDefaultSpecifierType> {
   const node = detachedProps<ImportDefaultSpecifierType>(props.parent, {
     type: 'ImportDefaultSpecifier',
+    // $FlowFixMe[incompatible-call],
     local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
@@ -1855,7 +1910,9 @@ export function ImportExpression(props: {
 }): DetachedNode<ImportExpressionType> {
   const node = detachedProps<ImportExpressionType>(props.parent, {
     type: 'ImportExpression',
+    // $FlowFixMe[incompatible-call],
     source: asDetachedNode(props.source),
+    // $FlowFixMe[incompatible-call],
     attributes: asDetachedNode(props.attributes),
   });
   setParentPointersInDirectChildren(node);
@@ -1868,6 +1925,7 @@ export function ImportNamespaceSpecifier(props: {
 }): DetachedNode<ImportNamespaceSpecifierType> {
   const node = detachedProps<ImportNamespaceSpecifierType>(props.parent, {
     type: 'ImportNamespaceSpecifier',
+    // $FlowFixMe[incompatible-call],
     local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
@@ -1880,7 +1938,9 @@ export function ImportSpecifier(props: {
 }): DetachedNode<ImportSpecifierType> {
   const node = detachedProps<ImportSpecifierType>(props.parent, {
     type: 'ImportSpecifier',
+    // $FlowFixMe[incompatible-call],
     imported: asDetachedNode(props.imported),
+    // $FlowFixMe[incompatible-call],
     local: asDetachedNode(props.local),
     importKind: props.importKind,
   });
@@ -1894,7 +1954,9 @@ export function IndexedAccessType(props: {
 }): DetachedNode<IndexedAccessTypeType> {
   const node = detachedProps<IndexedAccessTypeType>(props.parent, {
     type: 'IndexedAccessType',
+    // $FlowFixMe[incompatible-call],
     objectType: asDetachedNode(props.objectType),
+    // $FlowFixMe[incompatible-call],
     indexType: asDetachedNode(props.indexType),
   });
   setParentPointersInDirectChildren(node);
@@ -1917,9 +1979,13 @@ export function InterfaceDeclaration(props: {
 }): DetachedNode<InterfaceDeclarationType> {
   const node = detachedProps<InterfaceDeclarationType>(props.parent, {
     type: 'InterfaceDeclaration',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     extends: props.extends.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1932,7 +1998,9 @@ export function InterfaceExtends(props: {
 }): DetachedNode<InterfaceExtendsType> {
   const node = detachedProps<InterfaceExtendsType>(props.parent, {
     type: 'InterfaceExtends',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
@@ -1945,7 +2013,9 @@ export function InterfaceTypeAnnotation(props: {
 }): DetachedNode<InterfaceTypeAnnotationType> {
   const node = detachedProps<InterfaceTypeAnnotationType>(props.parent, {
     type: 'InterfaceTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     extends: props.extends.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -1958,6 +2028,7 @@ export function IntersectionTypeAnnotation(props: {
 }): DetachedNode<IntersectionTypeAnnotationType> {
   const node = detachedProps<IntersectionTypeAnnotationType>(props.parent, {
     type: 'IntersectionTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -1970,7 +2041,9 @@ export function JSXAttribute(props: {
 }): DetachedNode<JSXAttributeType> {
   const node = detachedProps<JSXAttributeType>(props.parent, {
     type: 'JSXAttribute',
+    // $FlowFixMe[incompatible-call],
     name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
@@ -1983,6 +2056,7 @@ export function JSXClosingElement(props: {
 }): DetachedNode<JSXClosingElementType> {
   const node = detachedProps<JSXClosingElementType>(props.parent, {
     type: 'JSXClosingElement',
+    // $FlowFixMe[incompatible-call],
     name: asDetachedNode(props.name),
   });
   setParentPointersInDirectChildren(node);
@@ -2005,8 +2079,11 @@ export function JSXElement(props: {
 }): DetachedNode<JSXElementType> {
   const node = detachedProps<JSXElementType>(props.parent, {
     type: 'JSXElement',
+    // $FlowFixMe[incompatible-call],
     openingElement: asDetachedNode(props.openingElement),
+    // $FlowFixMe[incompatible-call],
     children: props.children.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     closingElement: asDetachedNode(props.closingElement),
   });
   setParentPointersInDirectChildren(node);
@@ -2029,6 +2106,7 @@ export function JSXExpressionContainer(props: {
 }): DetachedNode<JSXExpressionContainerType> {
   const node = detachedProps<JSXExpressionContainerType>(props.parent, {
     type: 'JSXExpressionContainer',
+    // $FlowFixMe[incompatible-call],
     expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
@@ -2041,8 +2119,11 @@ export function JSXFragment(props: {
 }): DetachedNode<JSXFragmentType> {
   const node = detachedProps<JSXFragmentType>(props.parent, {
     type: 'JSXFragment',
+    // $FlowFixMe[incompatible-call],
     openingFragment: asDetachedNode(props.openingFragment),
+    // $FlowFixMe[incompatible-call],
     children: props.children.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     closingFragment: asDetachedNode(props.closingFragment),
   });
   setParentPointersInDirectChildren(node);
@@ -2067,7 +2148,9 @@ export function JSXMemberExpression(props: {
 }): DetachedNode<JSXMemberExpressionType> {
   const node = detachedProps<JSXMemberExpressionType>(props.parent, {
     type: 'JSXMemberExpression',
+    // $FlowFixMe[incompatible-call],
     object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
     property: asDetachedNode(props.property),
   });
   setParentPointersInDirectChildren(node);
@@ -2080,7 +2163,9 @@ export function JSXNamespacedName(props: {
 }): DetachedNode<JSXNamespacedNameType> {
   const node = detachedProps<JSXNamespacedNameType>(props.parent, {
     type: 'JSXNamespacedName',
+    // $FlowFixMe[incompatible-call],
     namespace: asDetachedNode(props.namespace),
+    // $FlowFixMe[incompatible-call],
     name: asDetachedNode(props.name),
   });
   setParentPointersInDirectChildren(node);
@@ -2093,7 +2178,9 @@ export function JSXOpeningElement(props: {
 }): DetachedNode<JSXOpeningElementType> {
   const node = detachedProps<JSXOpeningElementType>(props.parent, {
     type: 'JSXOpeningElement',
+    // $FlowFixMe[incompatible-call],
     name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
     attributes: props.attributes.map(n => asDetachedNode(n)),
     selfClosing: props.selfClosing,
   });
@@ -2117,6 +2204,7 @@ export function JSXSpreadAttribute(props: {
 }): DetachedNode<JSXSpreadAttributeType> {
   const node = detachedProps<JSXSpreadAttributeType>(props.parent, {
     type: 'JSXSpreadAttribute',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2129,6 +2217,7 @@ export function JSXSpreadChild(props: {
 }): DetachedNode<JSXSpreadChildType> {
   const node = detachedProps<JSXSpreadChildType>(props.parent, {
     type: 'JSXSpreadChild',
+    // $FlowFixMe[incompatible-call],
     expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
@@ -2154,7 +2243,9 @@ export function LabeledStatement(props: {
 }): DetachedNode<LabeledStatementType> {
   const node = detachedProps<LabeledStatementType>(props.parent, {
     type: 'LabeledStatement',
+    // $FlowFixMe[incompatible-call],
     label: asDetachedNode(props.label),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -2167,7 +2258,9 @@ export function LogicalExpression(props: {
 }): DetachedNode<LogicalExpressionType> {
   const node = detachedProps<LogicalExpressionType>(props.parent, {
     type: 'LogicalExpression',
+    // $FlowFixMe[incompatible-call],
     left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
     operator: props.operator,
   });
@@ -2181,7 +2274,9 @@ export function MemberExpression(props: {
 }): DetachedNode<MemberExpressionType> {
   const node = detachedProps<MemberExpressionType>(props.parent, {
     type: 'MemberExpression',
+    // $FlowFixMe[incompatible-call],
     object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
     property: asDetachedNode(props.property),
     computed: props.computed,
   });
@@ -2195,7 +2290,9 @@ export function MetaProperty(props: {
 }): DetachedNode<MetaPropertyType> {
   const node = detachedProps<MetaPropertyType>(props.parent, {
     type: 'MetaProperty',
+    // $FlowFixMe[incompatible-call],
     meta: asDetachedNode(props.meta),
+    // $FlowFixMe[incompatible-call],
     property: asDetachedNode(props.property),
   });
   setParentPointersInDirectChildren(node);
@@ -2208,7 +2305,9 @@ export function MethodDefinition(props: {
 }): DetachedNode<MethodDefinitionType> {
   const node = detachedProps<MethodDefinitionType>(props.parent, {
     type: 'MethodDefinition',
+    // $FlowFixMe[incompatible-call],
     key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     kind: props.kind,
     computed: props.computed,
@@ -2234,8 +2333,11 @@ export function NewExpression(props: {
 }): DetachedNode<NewExpressionType> {
   const node = detachedProps<NewExpressionType>(props.parent, {
     type: 'NewExpression',
+    // $FlowFixMe[incompatible-call],
     callee: asDetachedNode(props.callee),
+    // $FlowFixMe[incompatible-call],
     typeArguments: asDetachedNode(props.typeArguments),
+    // $FlowFixMe[incompatible-call],
     arguments: props.arguments.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2248,6 +2350,7 @@ export function NullableTypeAnnotation(props: {
 }): DetachedNode<NullableTypeAnnotationType> {
   const node = detachedProps<NullableTypeAnnotationType>(props.parent, {
     type: 'NullableTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -2293,6 +2396,7 @@ export function ObjectExpression(props: {
 }): DetachedNode<ObjectExpressionType> {
   const node = detachedProps<ObjectExpressionType>(props.parent, {
     type: 'ObjectExpression',
+    // $FlowFixMe[incompatible-call],
     properties: props.properties.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2305,7 +2409,9 @@ export function ObjectPattern(props: {
 }): DetachedNode<ObjectPatternType> {
   const node = detachedProps<ObjectPatternType>(props.parent, {
     type: 'ObjectPattern',
+    // $FlowFixMe[incompatible-call],
     properties: props.properties.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -2318,9 +2424,13 @@ export function ObjectTypeAnnotation(props: {
 }): DetachedNode<ObjectTypeAnnotationType> {
   const node = detachedProps<ObjectTypeAnnotationType>(props.parent, {
     type: 'ObjectTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     properties: props.properties.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     indexers: props.indexers.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     callProperties: props.callProperties.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     internalSlots: props.internalSlots.map(n => asDetachedNode(n)),
     inexact: props.inexact,
     exact: props.exact,
@@ -2335,6 +2445,7 @@ export function ObjectTypeCallProperty(props: {
 }): DetachedNode<ObjectTypeCallPropertyType> {
   const node = detachedProps<ObjectTypeCallPropertyType>(props.parent, {
     type: 'ObjectTypeCallProperty',
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     static: props.static,
   });
@@ -2348,10 +2459,14 @@ export function ObjectTypeIndexer(props: {
 }): DetachedNode<ObjectTypeIndexerType> {
   const node = detachedProps<ObjectTypeIndexerType>(props.parent, {
     type: 'ObjectTypeIndexer',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     static: props.static,
+    // $FlowFixMe[incompatible-call],
     variance: asDetachedNode(props.variance),
   });
   setParentPointersInDirectChildren(node);
@@ -2364,7 +2479,9 @@ export function ObjectTypeInternalSlot(props: {
 }): DetachedNode<ObjectTypeInternalSlotType> {
   const node = detachedProps<ObjectTypeInternalSlotType>(props.parent, {
     type: 'ObjectTypeInternalSlot',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     optional: props.optional,
     static: props.static,
@@ -2374,31 +2491,13 @@ export function ObjectTypeInternalSlot(props: {
   return node;
 }
 
-export function ObjectTypeProperty(props: {
-  ...$ReadOnly<ObjectTypePropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ObjectTypePropertyType> {
-  const node = detachedProps<ObjectTypePropertyType>(props.parent, {
-    type: 'ObjectTypeProperty',
-    key: asDetachedNode(props.key),
-    value: asDetachedNode(props.value),
-    method: props.method,
-    optional: props.optional,
-    static: props.static,
-    proto: props.proto,
-    variance: asDetachedNode(props.variance),
-    kind: props.kind,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
 export function ObjectTypeSpreadProperty(props: {
   ...$ReadOnly<ObjectTypeSpreadPropertyProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeSpreadPropertyType> {
   const node = detachedProps<ObjectTypeSpreadPropertyType>(props.parent, {
     type: 'ObjectTypeSpreadProperty',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2411,9 +2510,13 @@ export function OpaqueType(props: {
 }): DetachedNode<OpaqueTypeType> {
   const node = detachedProps<OpaqueTypeType>(props.parent, {
     type: 'OpaqueType',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     impltype: asDetachedNode(props.impltype),
+    // $FlowFixMe[incompatible-call],
     supertype: asDetachedNode(props.supertype),
   });
   setParentPointersInDirectChildren(node);
@@ -2426,7 +2529,9 @@ export function OptionalIndexedAccessType(props: {
 }): DetachedNode<OptionalIndexedAccessTypeType> {
   const node = detachedProps<OptionalIndexedAccessTypeType>(props.parent, {
     type: 'OptionalIndexedAccessType',
+    // $FlowFixMe[incompatible-call],
     objectType: asDetachedNode(props.objectType),
+    // $FlowFixMe[incompatible-call],
     indexType: asDetachedNode(props.indexType),
     optional: props.optional,
   });
@@ -2452,7 +2557,9 @@ export function Property(props: {
 }): DetachedNode<PropertyType> {
   const node = detachedProps<PropertyType>(props.parent, {
     type: 'Property',
+    // $FlowFixMe[incompatible-call],
     key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     kind: props.kind,
     computed: props.computed,
@@ -2469,14 +2576,20 @@ export function PropertyDefinition(props: {
 }): DetachedNode<PropertyDefinitionType> {
   const node = detachedProps<PropertyDefinitionType>(props.parent, {
     type: 'PropertyDefinition',
+    // $FlowFixMe[incompatible-call],
     key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
     value: asDetachedNode(props.value),
     computed: props.computed,
     static: props.static,
     declare: props.declare,
     optional: props.optional,
+    // $FlowFixMe[incompatible-call],
     variance: asDetachedNode(props.variance),
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
+    // $FlowFixMe[incompatible-call],
+    tsModifiers: asDetachedNode(props.tsModifiers),
   });
   setParentPointersInDirectChildren(node);
   return node;
@@ -2488,7 +2601,9 @@ export function QualifiedTypeIdentifier(props: {
 }): DetachedNode<QualifiedTypeIdentifierType> {
   const node = detachedProps<QualifiedTypeIdentifierType>(props.parent, {
     type: 'QualifiedTypeIdentifier',
+    // $FlowFixMe[incompatible-call],
     qualification: asDetachedNode(props.qualification),
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
@@ -2501,6 +2616,7 @@ export function RestElement(props: {
 }): DetachedNode<RestElementType> {
   const node = detachedProps<RestElementType>(props.parent, {
     type: 'RestElement',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2513,6 +2629,7 @@ export function ReturnStatement(props: {
 }): DetachedNode<ReturnStatementType> {
   const node = detachedProps<ReturnStatementType>(props.parent, {
     type: 'ReturnStatement',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2525,6 +2642,7 @@ export function SequenceExpression(props: {
 }): DetachedNode<SequenceExpressionType> {
   const node = detachedProps<SequenceExpressionType>(props.parent, {
     type: 'SequenceExpression',
+    // $FlowFixMe[incompatible-call],
     expressions: props.expressions.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2537,6 +2655,7 @@ export function SpreadElement(props: {
 }): DetachedNode<SpreadElementType> {
   const node = detachedProps<SpreadElementType>(props.parent, {
     type: 'SpreadElement',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2582,7 +2701,9 @@ export function SwitchCase(props: {
 }): DetachedNode<SwitchCaseType> {
   const node = detachedProps<SwitchCaseType>(props.parent, {
     type: 'SwitchCase',
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
     consequent: props.consequent.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2595,7 +2716,9 @@ export function SwitchStatement(props: {
 }): DetachedNode<SwitchStatementType> {
   const node = detachedProps<SwitchStatementType>(props.parent, {
     type: 'SwitchStatement',
+    // $FlowFixMe[incompatible-call],
     discriminant: asDetachedNode(props.discriminant),
+    // $FlowFixMe[incompatible-call],
     cases: props.cases.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2618,7 +2741,9 @@ export function TaggedTemplateExpression(props: {
 }): DetachedNode<TaggedTemplateExpressionType> {
   const node = detachedProps<TaggedTemplateExpressionType>(props.parent, {
     type: 'TaggedTemplateExpression',
+    // $FlowFixMe[incompatible-call],
     tag: asDetachedNode(props.tag),
+    // $FlowFixMe[incompatible-call],
     quasi: asDetachedNode(props.quasi),
   });
   setParentPointersInDirectChildren(node);
@@ -2631,7 +2756,9 @@ export function TemplateLiteral(props: {
 }): DetachedNode<TemplateLiteralType> {
   const node = detachedProps<TemplateLiteralType>(props.parent, {
     type: 'TemplateLiteral',
+    // $FlowFixMe[incompatible-call],
     quasis: props.quasis.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
     expressions: props.expressions.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2664,6 +2791,7 @@ export function ThrowStatement(props: {
 }): DetachedNode<ThrowStatementType> {
   const node = detachedProps<ThrowStatementType>(props.parent, {
     type: 'ThrowStatement',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2676,8 +2804,11 @@ export function TryStatement(props: {
 }): DetachedNode<TryStatementType> {
   const node = detachedProps<TryStatementType>(props.parent, {
     type: 'TryStatement',
+    // $FlowFixMe[incompatible-call],
     block: asDetachedNode(props.block),
+    // $FlowFixMe[incompatible-call],
     handler: asDetachedNode(props.handler),
+    // $FlowFixMe[incompatible-call],
     finalizer: asDetachedNode(props.finalizer),
   });
   setParentPointersInDirectChildren(node);
@@ -2690,6 +2821,7 @@ export function TupleTypeAnnotation(props: {
 }): DetachedNode<TupleTypeAnnotationType> {
   const node = detachedProps<TupleTypeAnnotationType>(props.parent, {
     type: 'TupleTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2702,8 +2834,11 @@ export function TypeAlias(props: {
 }): DetachedNode<TypeAliasType> {
   const node = detachedProps<TypeAliasType>(props.parent, {
     type: 'TypeAlias',
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
     typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
     right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
@@ -2716,6 +2851,7 @@ export function TypeAnnotation(props: {
 }): DetachedNode<TypeAnnotationType> {
   const node = detachedProps<TypeAnnotationType>(props.parent, {
     type: 'TypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -2728,7 +2864,9 @@ export function TypeCastExpression(props: {
 }): DetachedNode<TypeCastExpressionType> {
   const node = detachedProps<TypeCastExpressionType>(props.parent, {
     type: 'TypeCastExpression',
+    // $FlowFixMe[incompatible-call],
     expression: asDetachedNode(props.expression),
+    // $FlowFixMe[incompatible-call],
     typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
@@ -2741,6 +2879,7 @@ export function TypeofTypeAnnotation(props: {
 }): DetachedNode<TypeofTypeAnnotationType> {
   const node = detachedProps<TypeofTypeAnnotationType>(props.parent, {
     type: 'TypeofTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
@@ -2754,8 +2893,11 @@ export function TypeParameter(props: {
   const node = detachedProps<TypeParameterType>(props.parent, {
     type: 'TypeParameter',
     name: props.name,
+    // $FlowFixMe[incompatible-call],
     bound: asDetachedNode(props.bound),
+    // $FlowFixMe[incompatible-call],
     variance: asDetachedNode(props.variance),
+    // $FlowFixMe[incompatible-call],
     default: asDetachedNode(props.default),
   });
   setParentPointersInDirectChildren(node);
@@ -2768,6 +2910,7 @@ export function TypeParameterDeclaration(props: {
 }): DetachedNode<TypeParameterDeclarationType> {
   const node = detachedProps<TypeParameterDeclarationType>(props.parent, {
     type: 'TypeParameterDeclaration',
+    // $FlowFixMe[incompatible-call],
     params: props.params.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2780,6 +2923,7 @@ export function TypeParameterInstantiation(props: {
 }): DetachedNode<TypeParameterInstantiationType> {
   const node = detachedProps<TypeParameterInstantiationType>(props.parent, {
     type: 'TypeParameterInstantiation',
+    // $FlowFixMe[incompatible-call],
     params: props.params.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2793,6 +2937,7 @@ export function UnaryExpression(props: {
   const node = detachedProps<UnaryExpressionType>(props.parent, {
     type: 'UnaryExpression',
     operator: props.operator,
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
     prefix: props.prefix,
   });
@@ -2806,6 +2951,7 @@ export function UnionTypeAnnotation(props: {
 }): DetachedNode<UnionTypeAnnotationType> {
   const node = detachedProps<UnionTypeAnnotationType>(props.parent, {
     type: 'UnionTypeAnnotation',
+    // $FlowFixMe[incompatible-call],
     types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2819,6 +2965,7 @@ export function UpdateExpression(props: {
   const node = detachedProps<UpdateExpressionType>(props.parent, {
     type: 'UpdateExpression',
     operator: props.operator,
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
     prefix: props.prefix,
   });
@@ -2833,6 +2980,7 @@ export function VariableDeclaration(props: {
   const node = detachedProps<VariableDeclarationType>(props.parent, {
     type: 'VariableDeclaration',
     kind: props.kind,
+    // $FlowFixMe[incompatible-call],
     declarations: props.declarations.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
@@ -2845,7 +2993,9 @@ export function VariableDeclarator(props: {
 }): DetachedNode<VariableDeclaratorType> {
   const node = detachedProps<VariableDeclaratorType>(props.parent, {
     type: 'VariableDeclarator',
+    // $FlowFixMe[incompatible-call],
     init: asDetachedNode(props.init),
+    // $FlowFixMe[incompatible-call],
     id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
@@ -2880,7 +3030,9 @@ export function WhileStatement(props: {
 }): DetachedNode<WhileStatementType> {
   const node = detachedProps<WhileStatementType>(props.parent, {
     type: 'WhileStatement',
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
     test: asDetachedNode(props.test),
   });
   setParentPointersInDirectChildren(node);
@@ -2893,7 +3045,9 @@ export function WithStatement(props: {
 }): DetachedNode<WithStatementType> {
   const node = detachedProps<WithStatementType>(props.parent, {
     type: 'WithStatement',
+    // $FlowFixMe[incompatible-call],
     object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
     body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
@@ -2906,6 +3060,7 @@ export function YieldExpression(props: {
 }): DetachedNode<YieldExpressionType> {
   const node = detachedProps<YieldExpressionType>(props.parent, {
     type: 'YieldExpression',
+    // $FlowFixMe[incompatible-call],
     argument: asDetachedNode(props.argument),
     delegate: props.delegate,
   });