hermes-transform 0.8.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,
@@ -33,7 +41,6 @@ import type {
   CatchClause as CatchClauseType,
   ChainExpression as ChainExpressionType,
   ClassBody as ClassBodyType,
-  ClassDeclaration as ClassDeclarationType,
   ClassExpression as ClassExpressionType,
   ClassImplements as ClassImplementsType,
   ConditionalExpression as ConditionalExpressionType,
@@ -42,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,
@@ -65,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,
@@ -121,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,
@@ -164,9 +167,10 @@ import type {
   WithStatement as WithStatementType,
   YieldExpression as YieldExpressionType,
 } from 'hermes-estree';
-import type {DetachedNode} from '../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../detachedNode';
 
 import {
+  asDetachedNode,
   detachedProps,
   setParentPointersInDirectChildren,
 } from '../detachedNode';
@@ -175,47 +179,51 @@ export type AnyTypeAnnotationProps = {};
 
 export type ArrayExpressionProps = {
   +elements: $ReadOnlyArray<
-    DetachedNode<ArrayExpressionType['elements'][number]>,
+    MaybeDetachedNode<ArrayExpressionType['elements'][number]>,
   >,
   +trailingComma: ArrayExpressionType['trailingComma'],
 };
 
 export type ArrayPatternProps = {
-  +elements: $ReadOnlyArray<DetachedNode<ArrayPatternType['elements'][number]>>,
-  +typeAnnotation?: ?DetachedNode<ArrayPatternType['typeAnnotation']>,
+  +elements: $ReadOnlyArray<
+    MaybeDetachedNode<ArrayPatternType['elements'][number]>,
+  >,
+  +typeAnnotation?: ?MaybeDetachedNode<ArrayPatternType['typeAnnotation']>,
 };
 
 export type ArrayTypeAnnotationProps = {
-  +elementType: DetachedNode<ArrayTypeAnnotationType['elementType']>,
+  +elementType: MaybeDetachedNode<ArrayTypeAnnotationType['elementType']>,
 };
 
 export type AssignmentExpressionProps = {
   +operator: AssignmentExpressionType['operator'],
-  +left: DetachedNode<AssignmentExpressionType['left']>,
-  +right: DetachedNode<AssignmentExpressionType['right']>,
+  +left: MaybeDetachedNode<AssignmentExpressionType['left']>,
+  +right: MaybeDetachedNode<AssignmentExpressionType['right']>,
 };
 
 export type AssignmentPatternProps = {
-  +left: DetachedNode<AssignmentPatternType['left']>,
-  +right: DetachedNode<AssignmentPatternType['right']>,
+  +left: MaybeDetachedNode<AssignmentPatternType['left']>,
+  +right: MaybeDetachedNode<AssignmentPatternType['right']>,
 };
 
 export type AwaitExpressionProps = {
-  +argument: DetachedNode<AwaitExpressionType['argument']>,
+  +argument: MaybeDetachedNode<AwaitExpressionType['argument']>,
 };
 
 export type BigIntLiteralTypeAnnotationProps = {
   +raw: BigIntLiteralTypeAnnotationType['raw'],
 };
 
+export type BigIntTypeAnnotationProps = {};
+
 export type BinaryExpressionProps = {
-  +left: DetachedNode<BinaryExpressionType['left']>,
-  +right: DetachedNode<BinaryExpressionType['right']>,
+  +left: MaybeDetachedNode<BinaryExpressionType['left']>,
+  +right: MaybeDetachedNode<BinaryExpressionType['right']>,
   +operator: BinaryExpressionType['operator'],
 };
 
 export type BlockStatementProps = {
-  +body: $ReadOnlyArray<DetachedNode<BlockStatementType['body'][number]>>,
+  +body: $ReadOnlyArray<MaybeDetachedNode<BlockStatementType['body'][number]>>,
 };
 
 export type BooleanLiteralTypeAnnotationProps = {
@@ -226,151 +234,127 @@ export type BooleanLiteralTypeAnnotationProps = {
 export type BooleanTypeAnnotationProps = {};
 
 export type BreakStatementProps = {
-  +label?: ?DetachedNode<BreakStatementType['label']>,
+  +label?: ?MaybeDetachedNode<BreakStatementType['label']>,
 };
 
 export type CallExpressionProps = {
-  +callee: DetachedNode<CallExpressionType['callee']>,
-  +typeArguments?: ?DetachedNode<CallExpressionType['typeArguments']>,
+  +callee: MaybeDetachedNode<CallExpressionType['callee']>,
+  +typeArguments?: ?MaybeDetachedNode<CallExpressionType['typeArguments']>,
   +arguments: $ReadOnlyArray<
-    DetachedNode<CallExpressionType['arguments'][number]>,
+    MaybeDetachedNode<CallExpressionType['arguments'][number]>,
   >,
 };
 
 export type CatchClauseProps = {
-  +param?: ?DetachedNode<CatchClauseType['param']>,
-  +body: DetachedNode<CatchClauseType['body']>,
+  +param?: ?MaybeDetachedNode<CatchClauseType['param']>,
+  +body: MaybeDetachedNode<CatchClauseType['body']>,
 };
 
 export type ChainExpressionProps = {
-  +expression: DetachedNode<ChainExpressionType['expression']>,
+  +expression: MaybeDetachedNode<ChainExpressionType['expression']>,
 };
 
 export type ClassBodyProps = {
-  +body: $ReadOnlyArray<DetachedNode<ClassBodyType['body'][number]>>,
-};
-
-export type ClassDeclarationProps = {
-  +id?: ?DetachedNode<ClassDeclarationType['id']>,
-  +typeParameters?: ?DetachedNode<ClassDeclarationType['typeParameters']>,
-  +superClass?: ?DetachedNode<ClassDeclarationType['superClass']>,
-  +superTypeParameters?: ?DetachedNode<
-    ClassDeclarationType['superTypeParameters'],
-  >,
-  +implements: $ReadOnlyArray<
-    DetachedNode<ClassDeclarationType['implements'][number]>,
-  >,
-  +decorators: $ReadOnlyArray<
-    DetachedNode<ClassDeclarationType['decorators'][number]>,
-  >,
-  +body: DetachedNode<ClassDeclarationType['body']>,
+  +body: $ReadOnlyArray<MaybeDetachedNode<ClassBodyType['body'][number]>>,
 };
 
 export type ClassExpressionProps = {
-  +id?: ?DetachedNode<ClassExpressionType['id']>,
-  +typeParameters?: ?DetachedNode<ClassExpressionType['typeParameters']>,
-  +superClass?: ?DetachedNode<ClassExpressionType['superClass']>,
-  +superTypeParameters?: ?DetachedNode<
+  +id?: ?MaybeDetachedNode<ClassExpressionType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<ClassExpressionType['typeParameters']>,
+  +superClass?: ?MaybeDetachedNode<ClassExpressionType['superClass']>,
+  +superTypeParameters?: ?MaybeDetachedNode<
     ClassExpressionType['superTypeParameters'],
   >,
   +implements: $ReadOnlyArray<
-    DetachedNode<ClassExpressionType['implements'][number]>,
+    MaybeDetachedNode<ClassExpressionType['implements'][number]>,
   >,
   +decorators: $ReadOnlyArray<
-    DetachedNode<ClassExpressionType['decorators'][number]>,
+    MaybeDetachedNode<ClassExpressionType['decorators'][number]>,
   >,
-  +body: DetachedNode<ClassExpressionType['body']>,
+  +body: MaybeDetachedNode<ClassExpressionType['body']>,
 };
 
 export type ClassImplementsProps = {
-  +id: DetachedNode<ClassImplementsType['id']>,
-  +typeParameters?: ?DetachedNode<ClassImplementsType['typeParameters']>,
+  +id: MaybeDetachedNode<ClassImplementsType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<ClassImplementsType['typeParameters']>,
 };
 
 export type ConditionalExpressionProps = {
-  +test: DetachedNode<ConditionalExpressionType['test']>,
-  +alternate: DetachedNode<ConditionalExpressionType['alternate']>,
-  +consequent: DetachedNode<ConditionalExpressionType['consequent']>,
+  +test: MaybeDetachedNode<ConditionalExpressionType['test']>,
+  +alternate: MaybeDetachedNode<ConditionalExpressionType['alternate']>,
+  +consequent: MaybeDetachedNode<ConditionalExpressionType['consequent']>,
 };
 
 export type ContinueStatementProps = {
-  +label?: ?DetachedNode<ContinueStatementType['label']>,
+  +label?: ?MaybeDetachedNode<ContinueStatementType['label']>,
 };
 
 export type DebuggerStatementProps = {};
 
 export type DeclareClassProps = {
-  +id: DetachedNode<DeclareClassType['id']>,
-  +typeParameters?: ?DetachedNode<DeclareClassType['typeParameters']>,
-  +extends: $ReadOnlyArray<DetachedNode<DeclareClassType['extends'][number]>>,
+  +id: MaybeDetachedNode<DeclareClassType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<DeclareClassType['typeParameters']>,
+  +extends: $ReadOnlyArray<
+    MaybeDetachedNode<DeclareClassType['extends'][number]>,
+  >,
   +implements: $ReadOnlyArray<
-    DetachedNode<DeclareClassType['implements'][number]>,
+    MaybeDetachedNode<DeclareClassType['implements'][number]>,
+  >,
+  +mixins: $ReadOnlyArray<
+    MaybeDetachedNode<DeclareClassType['mixins'][number]>,
   >,
-  +mixins: $ReadOnlyArray<DetachedNode<DeclareClassType['mixins'][number]>>,
-  +body: DetachedNode<DeclareClassType['body']>,
+  +body: MaybeDetachedNode<DeclareClassType['body']>,
 };
 
 export type DeclaredPredicateProps = {
-  +value: DetachedNode<DeclaredPredicateType['value']>,
+  +value: MaybeDetachedNode<DeclaredPredicateType['value']>,
 };
 
 export type DeclareExportAllDeclarationProps = {
-  +source: DetachedNode<DeclareExportAllDeclarationType['source']>,
-};
-
-export type DeclareExportDeclarationProps = {
-  +declaration?: ?DetachedNode<DeclareExportDeclarationType['declaration']>,
-  +specifiers: $ReadOnlyArray<
-    DetachedNode<DeclareExportDeclarationType['specifiers'][number]>,
-  >,
-  +source?: ?DetachedNode<DeclareExportDeclarationType['source']>,
-  +default: DeclareExportDeclarationType['default'],
-};
-
-export type DeclareFunctionProps = {
-  +id: DetachedNode<DeclareFunctionType['id']>,
-  +predicate?: ?DetachedNode<DeclareFunctionType['predicate']>,
+  +source: MaybeDetachedNode<DeclareExportAllDeclarationType['source']>,
 };
 
 export type DeclareInterfaceProps = {
-  +id: DetachedNode<DeclareInterfaceType['id']>,
-  +typeParameters?: ?DetachedNode<DeclareInterfaceType['typeParameters']>,
+  +id: MaybeDetachedNode<DeclareInterfaceType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<DeclareInterfaceType['typeParameters']>,
   +extends: $ReadOnlyArray<
-    DetachedNode<DeclareInterfaceType['extends'][number]>,
+    MaybeDetachedNode<DeclareInterfaceType['extends'][number]>,
   >,
-  +body: DetachedNode<DeclareInterfaceType['body']>,
+  +body: MaybeDetachedNode<DeclareInterfaceType['body']>,
 };
 
 export type DeclareModuleProps = {
-  +id: DetachedNode<DeclareModuleType['id']>,
-  +body: DetachedNode<DeclareModuleType['body']>,
+  +id: MaybeDetachedNode<DeclareModuleType['id']>,
+  +body: MaybeDetachedNode<DeclareModuleType['body']>,
   +kind: DeclareModuleType['kind'],
 };
 
 export type DeclareModuleExportsProps = {
-  +typeAnnotation: DetachedNode<DeclareModuleExportsType['typeAnnotation']>,
+  +typeAnnotation: MaybeDetachedNode<
+    DeclareModuleExportsType['typeAnnotation'],
+  >,
 };
 
 export type DeclareOpaqueTypeProps = {
-  +id: DetachedNode<DeclareOpaqueTypeType['id']>,
-  +typeParameters?: ?DetachedNode<DeclareOpaqueTypeType['typeParameters']>,
-  +impltype?: ?DetachedNode<DeclareOpaqueTypeType['impltype']>,
-  +supertype?: ?DetachedNode<DeclareOpaqueTypeType['supertype']>,
+  +id: MaybeDetachedNode<DeclareOpaqueTypeType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<DeclareOpaqueTypeType['typeParameters']>,
+  +impltype?: ?MaybeDetachedNode<DeclareOpaqueTypeType['impltype']>,
+  +supertype?: ?MaybeDetachedNode<DeclareOpaqueTypeType['supertype']>,
 };
 
 export type DeclareTypeAliasProps = {
-  +id: DetachedNode<DeclareTypeAliasType['id']>,
-  +typeParameters?: ?DetachedNode<DeclareTypeAliasType['typeParameters']>,
-  +right: DetachedNode<DeclareTypeAliasType['right']>,
+  +id: MaybeDetachedNode<DeclareTypeAliasType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<DeclareTypeAliasType['typeParameters']>,
+  +right: MaybeDetachedNode<DeclareTypeAliasType['right']>,
 };
 
 export type DeclareVariableProps = {
-  +id: DetachedNode<DeclareVariableType['id']>,
+  +id: MaybeDetachedNode<DeclareVariableType['id']>,
 };
 
 export type DoWhileStatementProps = {
-  +body: DetachedNode<DoWhileStatementType['body']>,
-  +test: DetachedNode<DoWhileStatementType['test']>,
+  +body: MaybeDetachedNode<DoWhileStatementType['body']>,
+  +test: MaybeDetachedNode<DoWhileStatementType['test']>,
 };
 
 export type EmptyStatementProps = {};
@@ -379,253 +363,264 @@ export type EmptyTypeAnnotationProps = {};
 
 export type EnumBooleanBodyProps = {
   +members: $ReadOnlyArray<
-    DetachedNode<EnumBooleanBodyType['members'][number]>,
+    MaybeDetachedNode<EnumBooleanBodyType['members'][number]>,
   >,
   +explicitType: EnumBooleanBodyType['explicitType'],
   +hasUnknownMembers: EnumBooleanBodyType['hasUnknownMembers'],
 };
 
 export type EnumBooleanMemberProps = {
-  +id: DetachedNode<EnumBooleanMemberType['id']>,
-  +init: DetachedNode<EnumBooleanMemberType['init']>,
+  +id: MaybeDetachedNode<EnumBooleanMemberType['id']>,
+  +init: MaybeDetachedNode<EnumBooleanMemberType['init']>,
 };
 
 export type EnumDeclarationProps = {
-  +id: DetachedNode<EnumDeclarationType['id']>,
-  +body: DetachedNode<EnumDeclarationType['body']>,
+  +id: MaybeDetachedNode<EnumDeclarationType['id']>,
+  +body: MaybeDetachedNode<EnumDeclarationType['body']>,
 };
 
 export type EnumDefaultedMemberProps = {
-  +id: DetachedNode<EnumDefaultedMemberType['id']>,
+  +id: MaybeDetachedNode<EnumDefaultedMemberType['id']>,
 };
 
 export type EnumNumberBodyProps = {
-  +members: $ReadOnlyArray<DetachedNode<EnumNumberBodyType['members'][number]>>,
+  +members: $ReadOnlyArray<
+    MaybeDetachedNode<EnumNumberBodyType['members'][number]>,
+  >,
   +explicitType: EnumNumberBodyType['explicitType'],
   +hasUnknownMembers: EnumNumberBodyType['hasUnknownMembers'],
 };
 
 export type EnumNumberMemberProps = {
-  +id: DetachedNode<EnumNumberMemberType['id']>,
-  +init: DetachedNode<EnumNumberMemberType['init']>,
+  +id: MaybeDetachedNode<EnumNumberMemberType['id']>,
+  +init: MaybeDetachedNode<EnumNumberMemberType['init']>,
 };
 
 export type EnumStringBodyProps = {
-  +members: $ReadOnlyArray<DetachedNode<EnumStringBodyType['members'][number]>>,
+  +members: $ReadOnlyArray<
+    MaybeDetachedNode<EnumStringBodyType['members'][number]>,
+  >,
   +explicitType: EnumStringBodyType['explicitType'],
   +hasUnknownMembers: EnumStringBodyType['hasUnknownMembers'],
 };
 
 export type EnumStringMemberProps = {
-  +id: DetachedNode<EnumStringMemberType['id']>,
-  +init: DetachedNode<EnumStringMemberType['init']>,
+  +id: MaybeDetachedNode<EnumStringMemberType['id']>,
+  +init: MaybeDetachedNode<EnumStringMemberType['init']>,
 };
 
 export type EnumSymbolBodyProps = {
-  +members: $ReadOnlyArray<DetachedNode<EnumSymbolBodyType['members'][number]>>,
+  +members: $ReadOnlyArray<
+    MaybeDetachedNode<EnumSymbolBodyType['members'][number]>,
+  >,
   +hasUnknownMembers: EnumSymbolBodyType['hasUnknownMembers'],
 };
 
 export type ExistsTypeAnnotationProps = {};
 
 export type ExportAllDeclarationProps = {
-  +exported?: ?DetachedNode<ExportAllDeclarationType['exported']>,
-  +source: DetachedNode<ExportAllDeclarationType['source']>,
+  +exported?: ?MaybeDetachedNode<ExportAllDeclarationType['exported']>,
+  +source: MaybeDetachedNode<ExportAllDeclarationType['source']>,
   +exportKind: ExportAllDeclarationType['exportKind'],
 };
 
 export type ExportDefaultDeclarationProps = {
-  +declaration: DetachedNode<ExportDefaultDeclarationType['declaration']>,
-};
-
-export type ExportNamedDeclarationProps = {
-  +declaration?: ?DetachedNode<ExportNamedDeclarationType['declaration']>,
-  +specifiers: $ReadOnlyArray<
-    DetachedNode<ExportNamedDeclarationType['specifiers'][number]>,
-  >,
-  +source?: ?DetachedNode<ExportNamedDeclarationType['source']>,
-  +exportKind: ExportNamedDeclarationType['exportKind'],
+  +declaration: MaybeDetachedNode<ExportDefaultDeclarationType['declaration']>,
 };
 
 export type ExportSpecifierProps = {
-  +exported: DetachedNode<ExportSpecifierType['exported']>,
-  +local: DetachedNode<ExportSpecifierType['local']>,
+  +exported: MaybeDetachedNode<ExportSpecifierType['exported']>,
+  +local: MaybeDetachedNode<ExportSpecifierType['local']>,
 };
 
 export type ExpressionStatementProps = {
-  +expression: DetachedNode<ExpressionStatementType['expression']>,
+  +expression: MaybeDetachedNode<ExpressionStatementType['expression']>,
   +directive?: ?ExpressionStatementType['directive'],
 };
 
 export type ForInStatementProps = {
-  +left: DetachedNode<ForInStatementType['left']>,
-  +right: DetachedNode<ForInStatementType['right']>,
-  +body: DetachedNode<ForInStatementType['body']>,
+  +left: MaybeDetachedNode<ForInStatementType['left']>,
+  +right: MaybeDetachedNode<ForInStatementType['right']>,
+  +body: MaybeDetachedNode<ForInStatementType['body']>,
 };
 
 export type ForOfStatementProps = {
-  +left: DetachedNode<ForOfStatementType['left']>,
-  +right: DetachedNode<ForOfStatementType['right']>,
-  +body: DetachedNode<ForOfStatementType['body']>,
+  +left: MaybeDetachedNode<ForOfStatementType['left']>,
+  +right: MaybeDetachedNode<ForOfStatementType['right']>,
+  +body: MaybeDetachedNode<ForOfStatementType['body']>,
   +await: ForOfStatementType['await'],
 };
 
 export type ForStatementProps = {
-  +init?: ?DetachedNode<ForStatementType['init']>,
-  +test?: ?DetachedNode<ForStatementType['test']>,
-  +update?: ?DetachedNode<ForStatementType['update']>,
-  +body: DetachedNode<ForStatementType['body']>,
+  +init?: ?MaybeDetachedNode<ForStatementType['init']>,
+  +test?: ?MaybeDetachedNode<ForStatementType['test']>,
+  +update?: ?MaybeDetachedNode<ForStatementType['update']>,
+  +body: MaybeDetachedNode<ForStatementType['body']>,
 };
 
 export type FunctionDeclarationProps = {
-  +id?: ?DetachedNode<FunctionDeclarationType['id']>,
+  +id?: ?MaybeDetachedNode<FunctionDeclarationType['id']>,
   +params: $ReadOnlyArray<
-    DetachedNode<FunctionDeclarationType['params'][number]>,
+    MaybeDetachedNode<FunctionDeclarationType['params'][number]>,
+  >,
+  +body: MaybeDetachedNode<FunctionDeclarationType['body']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    FunctionDeclarationType['typeParameters'],
   >,
-  +body: DetachedNode<FunctionDeclarationType['body']>,
-  +typeParameters?: ?DetachedNode<FunctionDeclarationType['typeParameters']>,
-  +returnType?: ?DetachedNode<FunctionDeclarationType['returnType']>,
-  +predicate?: ?DetachedNode<FunctionDeclarationType['predicate']>,
+  +returnType?: ?MaybeDetachedNode<FunctionDeclarationType['returnType']>,
+  +predicate?: ?MaybeDetachedNode<FunctionDeclarationType['predicate']>,
   +generator: FunctionDeclarationType['generator'],
   +async: FunctionDeclarationType['async'],
 };
 
 export type FunctionExpressionProps = {
-  +id?: ?DetachedNode<FunctionExpressionType['id']>,
+  +id?: ?MaybeDetachedNode<FunctionExpressionType['id']>,
   +params: $ReadOnlyArray<
-    DetachedNode<FunctionExpressionType['params'][number]>,
+    MaybeDetachedNode<FunctionExpressionType['params'][number]>,
+  >,
+  +body: MaybeDetachedNode<FunctionExpressionType['body']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    FunctionExpressionType['typeParameters'],
   >,
-  +body: DetachedNode<FunctionExpressionType['body']>,
-  +typeParameters?: ?DetachedNode<FunctionExpressionType['typeParameters']>,
-  +returnType?: ?DetachedNode<FunctionExpressionType['returnType']>,
-  +predicate?: ?DetachedNode<FunctionExpressionType['predicate']>,
+  +returnType?: ?MaybeDetachedNode<FunctionExpressionType['returnType']>,
+  +predicate?: ?MaybeDetachedNode<FunctionExpressionType['predicate']>,
   +generator: FunctionExpressionType['generator'],
   +async: FunctionExpressionType['async'],
 };
 
 export type FunctionTypeAnnotationProps = {
   +params: $ReadOnlyArray<
-    DetachedNode<FunctionTypeAnnotationType['params'][number]>,
+    MaybeDetachedNode<FunctionTypeAnnotationType['params'][number]>,
+  >,
+  +this?: ?MaybeDetachedNode<FunctionTypeAnnotationType['this']>,
+  +returnType: MaybeDetachedNode<FunctionTypeAnnotationType['returnType']>,
+  +rest?: ?MaybeDetachedNode<FunctionTypeAnnotationType['rest']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    FunctionTypeAnnotationType['typeParameters'],
   >,
-  +this?: ?DetachedNode<FunctionTypeAnnotationType['this']>,
-  +returnType: DetachedNode<FunctionTypeAnnotationType['returnType']>,
-  +rest?: ?DetachedNode<FunctionTypeAnnotationType['rest']>,
-  +typeParameters?: ?DetachedNode<FunctionTypeAnnotationType['typeParameters']>,
 };
 
 export type FunctionTypeParamProps = {
-  +name?: ?DetachedNode<FunctionTypeParamType['name']>,
-  +typeAnnotation: DetachedNode<FunctionTypeParamType['typeAnnotation']>,
+  +name?: ?MaybeDetachedNode<FunctionTypeParamType['name']>,
+  +typeAnnotation: MaybeDetachedNode<FunctionTypeParamType['typeAnnotation']>,
   +optional: FunctionTypeParamType['optional'],
 };
 
 export type GenericTypeAnnotationProps = {
-  +id: DetachedNode<GenericTypeAnnotationType['id']>,
-  +typeParameters?: ?DetachedNode<GenericTypeAnnotationType['typeParameters']>,
+  +id: MaybeDetachedNode<GenericTypeAnnotationType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    GenericTypeAnnotationType['typeParameters'],
+  >,
 };
 
 export type IfStatementProps = {
-  +test: DetachedNode<IfStatementType['test']>,
-  +consequent: DetachedNode<IfStatementType['consequent']>,
-  +alternate?: ?DetachedNode<IfStatementType['alternate']>,
+  +test: MaybeDetachedNode<IfStatementType['test']>,
+  +consequent: MaybeDetachedNode<IfStatementType['consequent']>,
+  +alternate?: ?MaybeDetachedNode<IfStatementType['alternate']>,
 };
 
 export type ImportAttributeProps = {
-  +key: DetachedNode<ImportAttributeType['key']>,
-  +value: DetachedNode<ImportAttributeType['value']>,
+  +key: MaybeDetachedNode<ImportAttributeType['key']>,
+  +value: MaybeDetachedNode<ImportAttributeType['value']>,
 };
 
 export type ImportDeclarationProps = {
   +specifiers: $ReadOnlyArray<
-    DetachedNode<ImportDeclarationType['specifiers'][number]>,
+    MaybeDetachedNode<ImportDeclarationType['specifiers'][number]>,
   >,
-  +source: DetachedNode<ImportDeclarationType['source']>,
+  +source: MaybeDetachedNode<ImportDeclarationType['source']>,
   +assertions?: ?$ReadOnlyArray<
-    DetachedNode<ImportDeclarationType['assertions'][number]>,
+    MaybeDetachedNode<ImportDeclarationType['assertions'][number]>,
   >,
   +importKind: ImportDeclarationType['importKind'],
 };
 
 export type ImportDefaultSpecifierProps = {
-  +local: DetachedNode<ImportDefaultSpecifierType['local']>,
+  +local: MaybeDetachedNode<ImportDefaultSpecifierType['local']>,
 };
 
 export type ImportExpressionProps = {
-  +source: DetachedNode<ImportExpressionType['source']>,
-  +attributes?: ?DetachedNode<ImportExpressionType['attributes']>,
+  +source: MaybeDetachedNode<ImportExpressionType['source']>,
+  +attributes?: ?MaybeDetachedNode<ImportExpressionType['attributes']>,
 };
 
 export type ImportNamespaceSpecifierProps = {
-  +local: DetachedNode<ImportNamespaceSpecifierType['local']>,
+  +local: MaybeDetachedNode<ImportNamespaceSpecifierType['local']>,
 };
 
 export type ImportSpecifierProps = {
-  +imported: DetachedNode<ImportSpecifierType['imported']>,
-  +local: DetachedNode<ImportSpecifierType['local']>,
+  +imported: MaybeDetachedNode<ImportSpecifierType['imported']>,
+  +local: MaybeDetachedNode<ImportSpecifierType['local']>,
   +importKind: ImportSpecifierType['importKind'],
 };
 
 export type IndexedAccessTypeProps = {
-  +objectType: DetachedNode<IndexedAccessTypeType['objectType']>,
-  +indexType: DetachedNode<IndexedAccessTypeType['indexType']>,
+  +objectType: MaybeDetachedNode<IndexedAccessTypeType['objectType']>,
+  +indexType: MaybeDetachedNode<IndexedAccessTypeType['indexType']>,
 };
 
 export type InferredPredicateProps = {};
 
 export type InterfaceDeclarationProps = {
-  +id: DetachedNode<InterfaceDeclarationType['id']>,
-  +typeParameters?: ?DetachedNode<InterfaceDeclarationType['typeParameters']>,
+  +id: MaybeDetachedNode<InterfaceDeclarationType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<
+    InterfaceDeclarationType['typeParameters'],
+  >,
   +extends: $ReadOnlyArray<
-    DetachedNode<InterfaceDeclarationType['extends'][number]>,
+    MaybeDetachedNode<InterfaceDeclarationType['extends'][number]>,
   >,
-  +body: DetachedNode<InterfaceDeclarationType['body']>,
+  +body: MaybeDetachedNode<InterfaceDeclarationType['body']>,
 };
 
 export type InterfaceExtendsProps = {
-  +id: DetachedNode<InterfaceExtendsType['id']>,
-  +typeParameters?: ?DetachedNode<InterfaceExtendsType['typeParameters']>,
+  +id: MaybeDetachedNode<InterfaceExtendsType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<InterfaceExtendsType['typeParameters']>,
 };
 
 export type InterfaceTypeAnnotationProps = {
   +extends: $ReadOnlyArray<
-    DetachedNode<InterfaceTypeAnnotationType['extends'][number]>,
+    MaybeDetachedNode<InterfaceTypeAnnotationType['extends'][number]>,
   >,
-  +body?: ?DetachedNode<InterfaceTypeAnnotationType['body']>,
+  +body?: ?MaybeDetachedNode<InterfaceTypeAnnotationType['body']>,
 };
 
 export type IntersectionTypeAnnotationProps = {
   +types: $ReadOnlyArray<
-    DetachedNode<IntersectionTypeAnnotationType['types'][number]>,
+    MaybeDetachedNode<IntersectionTypeAnnotationType['types'][number]>,
   >,
 };
 
 export type JSXAttributeProps = {
-  +name: DetachedNode<JSXAttributeType['name']>,
-  +value?: ?DetachedNode<JSXAttributeType['value']>,
+  +name: MaybeDetachedNode<JSXAttributeType['name']>,
+  +value?: ?MaybeDetachedNode<JSXAttributeType['value']>,
 };
 
 export type JSXClosingElementProps = {
-  +name: DetachedNode<JSXClosingElementType['name']>,
+  +name: MaybeDetachedNode<JSXClosingElementType['name']>,
 };
 
 export type JSXClosingFragmentProps = {};
 
 export type JSXElementProps = {
-  +openingElement: DetachedNode<JSXElementType['openingElement']>,
-  +children: $ReadOnlyArray<DetachedNode<JSXElementType['children'][number]>>,
-  +closingElement?: ?DetachedNode<JSXElementType['closingElement']>,
+  +openingElement: MaybeDetachedNode<JSXElementType['openingElement']>,
+  +children: $ReadOnlyArray<
+    MaybeDetachedNode<JSXElementType['children'][number]>,
+  >,
+  +closingElement?: ?MaybeDetachedNode<JSXElementType['closingElement']>,
 };
 
 export type JSXEmptyExpressionProps = {};
 
 export type JSXExpressionContainerProps = {
-  +expression: DetachedNode<JSXExpressionContainerType['expression']>,
+  +expression: MaybeDetachedNode<JSXExpressionContainerType['expression']>,
 };
 
 export type JSXFragmentProps = {
-  +openingFragment: DetachedNode<JSXFragmentType['openingFragment']>,
-  +children: $ReadOnlyArray<DetachedNode<JSXFragmentType['children'][number]>>,
-  +closingFragment: DetachedNode<JSXFragmentType['closingFragment']>,
+  +openingFragment: MaybeDetachedNode<JSXFragmentType['openingFragment']>,
+  +children: $ReadOnlyArray<
+    MaybeDetachedNode<JSXFragmentType['children'][number]>,
+  >,
+  +closingFragment: MaybeDetachedNode<JSXFragmentType['closingFragment']>,
 };
 
 export type JSXIdentifierProps = {
@@ -633,19 +628,19 @@ export type JSXIdentifierProps = {
 };
 
 export type JSXMemberExpressionProps = {
-  +object: DetachedNode<JSXMemberExpressionType['object']>,
-  +property: DetachedNode<JSXMemberExpressionType['property']>,
+  +object: MaybeDetachedNode<JSXMemberExpressionType['object']>,
+  +property: MaybeDetachedNode<JSXMemberExpressionType['property']>,
 };
 
 export type JSXNamespacedNameProps = {
-  +namespace: DetachedNode<JSXNamespacedNameType['namespace']>,
-  +name: DetachedNode<JSXNamespacedNameType['name']>,
+  +namespace: MaybeDetachedNode<JSXNamespacedNameType['namespace']>,
+  +name: MaybeDetachedNode<JSXNamespacedNameType['name']>,
 };
 
 export type JSXOpeningElementProps = {
-  +name: DetachedNode<JSXOpeningElementType['name']>,
+  +name: MaybeDetachedNode<JSXOpeningElementType['name']>,
   +attributes: $ReadOnlyArray<
-    DetachedNode<JSXOpeningElementType['attributes'][number]>,
+    MaybeDetachedNode<JSXOpeningElementType['attributes'][number]>,
   >,
   +selfClosing: JSXOpeningElementType['selfClosing'],
 };
@@ -653,11 +648,11 @@ export type JSXOpeningElementProps = {
 export type JSXOpeningFragmentProps = {};
 
 export type JSXSpreadAttributeProps = {
-  +argument: DetachedNode<JSXSpreadAttributeType['argument']>,
+  +argument: MaybeDetachedNode<JSXSpreadAttributeType['argument']>,
 };
 
 export type JSXSpreadChildProps = {
-  +expression: DetachedNode<JSXSpreadChildType['expression']>,
+  +expression: MaybeDetachedNode<JSXSpreadChildType['expression']>,
 };
 
 export type JSXTextProps = {
@@ -666,30 +661,30 @@ export type JSXTextProps = {
 };
 
 export type LabeledStatementProps = {
-  +label: DetachedNode<LabeledStatementType['label']>,
-  +body: DetachedNode<LabeledStatementType['body']>,
+  +label: MaybeDetachedNode<LabeledStatementType['label']>,
+  +body: MaybeDetachedNode<LabeledStatementType['body']>,
 };
 
 export type LogicalExpressionProps = {
-  +left: DetachedNode<LogicalExpressionType['left']>,
-  +right: DetachedNode<LogicalExpressionType['right']>,
+  +left: MaybeDetachedNode<LogicalExpressionType['left']>,
+  +right: MaybeDetachedNode<LogicalExpressionType['right']>,
   +operator: LogicalExpressionType['operator'],
 };
 
 export type MemberExpressionProps = {
-  +object: DetachedNode<MemberExpressionType['object']>,
-  +property: DetachedNode<MemberExpressionType['property']>,
+  +object: MaybeDetachedNode<MemberExpressionType['object']>,
+  +property: MaybeDetachedNode<MemberExpressionType['property']>,
   +computed: MemberExpressionType['computed'],
 };
 
 export type MetaPropertyProps = {
-  +meta: DetachedNode<MetaPropertyType['meta']>,
-  +property: DetachedNode<MetaPropertyType['property']>,
+  +meta: MaybeDetachedNode<MetaPropertyType['meta']>,
+  +property: MaybeDetachedNode<MetaPropertyType['property']>,
 };
 
 export type MethodDefinitionProps = {
-  +key: DetachedNode<MethodDefinitionType['key']>,
-  +value: DetachedNode<MethodDefinitionType['value']>,
+  +key: MaybeDetachedNode<MethodDefinitionType['key']>,
+  +value: MaybeDetachedNode<MethodDefinitionType['value']>,
   +kind: MethodDefinitionType['kind'],
   +computed: MethodDefinitionType['computed'],
   +static: MethodDefinitionType['static'],
@@ -698,15 +693,17 @@ export type MethodDefinitionProps = {
 export type MixedTypeAnnotationProps = {};
 
 export type NewExpressionProps = {
-  +callee: DetachedNode<NewExpressionType['callee']>,
-  +typeArguments?: ?DetachedNode<NewExpressionType['typeArguments']>,
+  +callee: MaybeDetachedNode<NewExpressionType['callee']>,
+  +typeArguments?: ?MaybeDetachedNode<NewExpressionType['typeArguments']>,
   +arguments: $ReadOnlyArray<
-    DetachedNode<NewExpressionType['arguments'][number]>,
+    MaybeDetachedNode<NewExpressionType['arguments'][number]>,
   >,
 };
 
 export type NullableTypeAnnotationProps = {
-  +typeAnnotation: DetachedNode<NullableTypeAnnotationType['typeAnnotation']>,
+  +typeAnnotation: MaybeDetachedNode<
+    NullableTypeAnnotationType['typeAnnotation'],
+  >,
 };
 
 export type NullLiteralTypeAnnotationProps = {};
@@ -720,80 +717,69 @@ export type NumberTypeAnnotationProps = {};
 
 export type ObjectExpressionProps = {
   +properties: $ReadOnlyArray<
-    DetachedNode<ObjectExpressionType['properties'][number]>,
+    MaybeDetachedNode<ObjectExpressionType['properties'][number]>,
   >,
 };
 
 export type ObjectPatternProps = {
   +properties: $ReadOnlyArray<
-    DetachedNode<ObjectPatternType['properties'][number]>,
+    MaybeDetachedNode<ObjectPatternType['properties'][number]>,
   >,
-  +typeAnnotation?: ?DetachedNode<ObjectPatternType['typeAnnotation']>,
+  +typeAnnotation?: ?MaybeDetachedNode<ObjectPatternType['typeAnnotation']>,
 };
 
 export type ObjectTypeAnnotationProps = {
   +properties: $ReadOnlyArray<
-    DetachedNode<ObjectTypeAnnotationType['properties'][number]>,
+    MaybeDetachedNode<ObjectTypeAnnotationType['properties'][number]>,
   >,
   +indexers: $ReadOnlyArray<
-    DetachedNode<ObjectTypeAnnotationType['indexers'][number]>,
+    MaybeDetachedNode<ObjectTypeAnnotationType['indexers'][number]>,
   >,
   +callProperties: $ReadOnlyArray<
-    DetachedNode<ObjectTypeAnnotationType['callProperties'][number]>,
+    MaybeDetachedNode<ObjectTypeAnnotationType['callProperties'][number]>,
   >,
   +internalSlots: $ReadOnlyArray<
-    DetachedNode<ObjectTypeAnnotationType['internalSlots'][number]>,
+    MaybeDetachedNode<ObjectTypeAnnotationType['internalSlots'][number]>,
   >,
   +inexact: ObjectTypeAnnotationType['inexact'],
   +exact: ObjectTypeAnnotationType['exact'],
 };
 
 export type ObjectTypeCallPropertyProps = {
-  +value: DetachedNode<ObjectTypeCallPropertyType['value']>,
+  +value: MaybeDetachedNode<ObjectTypeCallPropertyType['value']>,
   +static: ObjectTypeCallPropertyType['static'],
 };
 
 export type ObjectTypeIndexerProps = {
-  +id?: ?DetachedNode<ObjectTypeIndexerType['id']>,
-  +key: DetachedNode<ObjectTypeIndexerType['key']>,
-  +value: DetachedNode<ObjectTypeIndexerType['value']>,
+  +id?: ?MaybeDetachedNode<ObjectTypeIndexerType['id']>,
+  +key: MaybeDetachedNode<ObjectTypeIndexerType['key']>,
+  +value: MaybeDetachedNode<ObjectTypeIndexerType['value']>,
   +static: ObjectTypeIndexerType['static'],
-  +variance?: ?DetachedNode<ObjectTypeIndexerType['variance']>,
+  +variance?: ?MaybeDetachedNode<ObjectTypeIndexerType['variance']>,
 };
 
 export type ObjectTypeInternalSlotProps = {
-  +id: DetachedNode<ObjectTypeInternalSlotType['id']>,
-  +value: DetachedNode<ObjectTypeInternalSlotType['value']>,
+  +id: MaybeDetachedNode<ObjectTypeInternalSlotType['id']>,
+  +value: MaybeDetachedNode<ObjectTypeInternalSlotType['value']>,
   +optional: ObjectTypeInternalSlotType['optional'],
   +static: ObjectTypeInternalSlotType['static'],
   +method: ObjectTypeInternalSlotType['method'],
 };
 
-export type ObjectTypePropertyProps = {
-  +key: DetachedNode<ObjectTypePropertyType['key']>,
-  +value: DetachedNode<ObjectTypePropertyType['value']>,
-  +method: ObjectTypePropertyType['method'],
-  +optional: ObjectTypePropertyType['optional'],
-  +static: ObjectTypePropertyType['static'],
-  +proto: ObjectTypePropertyType['proto'],
-  +variance?: ?DetachedNode<ObjectTypePropertyType['variance']>,
-  +kind: ObjectTypePropertyType['kind'],
-};
-
 export type ObjectTypeSpreadPropertyProps = {
-  +argument: DetachedNode<ObjectTypeSpreadPropertyType['argument']>,
+  +argument: MaybeDetachedNode<ObjectTypeSpreadPropertyType['argument']>,
 };
 
 export type OpaqueTypeProps = {
-  +id: DetachedNode<OpaqueTypeType['id']>,
-  +typeParameters?: ?DetachedNode<OpaqueTypeType['typeParameters']>,
-  +impltype: DetachedNode<OpaqueTypeType['impltype']>,
-  +supertype?: ?DetachedNode<OpaqueTypeType['supertype']>,
+  +id: MaybeDetachedNode<OpaqueTypeType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<OpaqueTypeType['typeParameters']>,
+  +impltype: MaybeDetachedNode<OpaqueTypeType['impltype']>,
+  +supertype?: ?MaybeDetachedNode<OpaqueTypeType['supertype']>,
 };
 
 export type OptionalIndexedAccessTypeProps = {
-  +objectType: DetachedNode<OptionalIndexedAccessTypeType['objectType']>,
-  +indexType: DetachedNode<OptionalIndexedAccessTypeType['indexType']>,
+  +objectType: MaybeDetachedNode<OptionalIndexedAccessTypeType['objectType']>,
+  +indexType: MaybeDetachedNode<OptionalIndexedAccessTypeType['indexType']>,
   +optional: OptionalIndexedAccessTypeType['optional'],
 };
 
@@ -802,8 +788,8 @@ export type PrivateIdentifierProps = {
 };
 
 export type PropertyProps = {
-  +key: DetachedNode<PropertyType['key']>,
-  +value: DetachedNode<PropertyType['value']>,
+  +key: MaybeDetachedNode<PropertyType['key']>,
+  +value: MaybeDetachedNode<PropertyType['value']>,
   +kind: PropertyType['kind'],
   +computed: PropertyType['computed'],
   +method: PropertyType['method'],
@@ -811,37 +797,42 @@ export type PropertyProps = {
 };
 
 export type PropertyDefinitionProps = {
-  +key: DetachedNode<PropertyDefinitionType['key']>,
-  +value?: ?DetachedNode<PropertyDefinitionType['value']>,
+  +key: MaybeDetachedNode<PropertyDefinitionType['key']>,
+  +value?: ?MaybeDetachedNode<PropertyDefinitionType['value']>,
   +computed: PropertyDefinitionType['computed'],
   +static: PropertyDefinitionType['static'],
   +declare: PropertyDefinitionType['declare'],
   +optional: PropertyDefinitionType['optional'],
-  +variance?: ?DetachedNode<PropertyDefinitionType['variance']>,
-  +typeAnnotation?: ?DetachedNode<PropertyDefinitionType['typeAnnotation']>,
+  +variance?: ?MaybeDetachedNode<PropertyDefinitionType['variance']>,
+  +typeAnnotation?: ?MaybeDetachedNode<
+    PropertyDefinitionType['typeAnnotation'],
+  >,
+  +tsModifiers?: ?MaybeDetachedNode<PropertyDefinitionType['tsModifiers']>,
 };
 
 export type QualifiedTypeIdentifierProps = {
-  +qualification: DetachedNode<QualifiedTypeIdentifierType['qualification']>,
-  +id: DetachedNode<QualifiedTypeIdentifierType['id']>,
+  +qualification: MaybeDetachedNode<
+    QualifiedTypeIdentifierType['qualification'],
+  >,
+  +id: MaybeDetachedNode<QualifiedTypeIdentifierType['id']>,
 };
 
 export type RestElementProps = {
-  +argument: DetachedNode<RestElementType['argument']>,
+  +argument: MaybeDetachedNode<RestElementType['argument']>,
 };
 
 export type ReturnStatementProps = {
-  +argument?: ?DetachedNode<ReturnStatementType['argument']>,
+  +argument?: ?MaybeDetachedNode<ReturnStatementType['argument']>,
 };
 
 export type SequenceExpressionProps = {
   +expressions: $ReadOnlyArray<
-    DetachedNode<SequenceExpressionType['expressions'][number]>,
+    MaybeDetachedNode<SequenceExpressionType['expressions'][number]>,
   >,
 };
 
 export type SpreadElementProps = {
-  +argument: DetachedNode<SpreadElementType['argument']>,
+  +argument: MaybeDetachedNode<SpreadElementType['argument']>,
 };
 
 export type StringLiteralTypeAnnotationProps = {
@@ -854,28 +845,32 @@ export type StringTypeAnnotationProps = {};
 export type SuperProps = {};
 
 export type SwitchCaseProps = {
-  +test?: ?DetachedNode<SwitchCaseType['test']>,
+  +test?: ?MaybeDetachedNode<SwitchCaseType['test']>,
   +consequent: $ReadOnlyArray<
-    DetachedNode<SwitchCaseType['consequent'][number]>,
+    MaybeDetachedNode<SwitchCaseType['consequent'][number]>,
   >,
 };
 
 export type SwitchStatementProps = {
-  +discriminant: DetachedNode<SwitchStatementType['discriminant']>,
-  +cases: $ReadOnlyArray<DetachedNode<SwitchStatementType['cases'][number]>>,
+  +discriminant: MaybeDetachedNode<SwitchStatementType['discriminant']>,
+  +cases: $ReadOnlyArray<
+    MaybeDetachedNode<SwitchStatementType['cases'][number]>,
+  >,
 };
 
 export type SymbolTypeAnnotationProps = {};
 
 export type TaggedTemplateExpressionProps = {
-  +tag: DetachedNode<TaggedTemplateExpressionType['tag']>,
-  +quasi: DetachedNode<TaggedTemplateExpressionType['quasi']>,
+  +tag: MaybeDetachedNode<TaggedTemplateExpressionType['tag']>,
+  +quasi: MaybeDetachedNode<TaggedTemplateExpressionType['quasi']>,
 };
 
 export type TemplateLiteralProps = {
-  +quasis: $ReadOnlyArray<DetachedNode<TemplateLiteralType['quasis'][number]>>,
+  +quasis: $ReadOnlyArray<
+    MaybeDetachedNode<TemplateLiteralType['quasis'][number]>,
+  >,
   +expressions: $ReadOnlyArray<
-    DetachedNode<TemplateLiteralType['expressions'][number]>,
+    MaybeDetachedNode<TemplateLiteralType['expressions'][number]>,
   >,
 };
 
@@ -884,87 +879,87 @@ export type ThisExpressionProps = {};
 export type ThisTypeAnnotationProps = {};
 
 export type ThrowStatementProps = {
-  +argument: DetachedNode<ThrowStatementType['argument']>,
+  +argument: MaybeDetachedNode<ThrowStatementType['argument']>,
 };
 
 export type TryStatementProps = {
-  +block: DetachedNode<TryStatementType['block']>,
-  +handler?: ?DetachedNode<TryStatementType['handler']>,
-  +finalizer?: ?DetachedNode<TryStatementType['finalizer']>,
+  +block: MaybeDetachedNode<TryStatementType['block']>,
+  +handler?: ?MaybeDetachedNode<TryStatementType['handler']>,
+  +finalizer?: ?MaybeDetachedNode<TryStatementType['finalizer']>,
 };
 
 export type TupleTypeAnnotationProps = {
   +types: $ReadOnlyArray<
-    DetachedNode<TupleTypeAnnotationType['types'][number]>,
+    MaybeDetachedNode<TupleTypeAnnotationType['types'][number]>,
   >,
 };
 
 export type TypeAliasProps = {
-  +id: DetachedNode<TypeAliasType['id']>,
-  +typeParameters?: ?DetachedNode<TypeAliasType['typeParameters']>,
-  +right: DetachedNode<TypeAliasType['right']>,
+  +id: MaybeDetachedNode<TypeAliasType['id']>,
+  +typeParameters?: ?MaybeDetachedNode<TypeAliasType['typeParameters']>,
+  +right: MaybeDetachedNode<TypeAliasType['right']>,
 };
 
 export type TypeAnnotationProps = {
-  +typeAnnotation: DetachedNode<TypeAnnotationType['typeAnnotation']>,
+  +typeAnnotation: MaybeDetachedNode<TypeAnnotationType['typeAnnotation']>,
 };
 
 export type TypeCastExpressionProps = {
-  +expression: DetachedNode<TypeCastExpressionType['expression']>,
-  +typeAnnotation: DetachedNode<TypeCastExpressionType['typeAnnotation']>,
+  +expression: MaybeDetachedNode<TypeCastExpressionType['expression']>,
+  +typeAnnotation: MaybeDetachedNode<TypeCastExpressionType['typeAnnotation']>,
 };
 
 export type TypeofTypeAnnotationProps = {
-  +argument: DetachedNode<TypeofTypeAnnotationType['argument']>,
+  +argument: MaybeDetachedNode<TypeofTypeAnnotationType['argument']>,
 };
 
 export type TypeParameterProps = {
   +name: TypeParameterType['name'],
-  +bound?: ?DetachedNode<TypeParameterType['bound']>,
-  +variance?: ?DetachedNode<TypeParameterType['variance']>,
-  +default?: ?DetachedNode<TypeParameterType['default']>,
+  +bound?: ?MaybeDetachedNode<TypeParameterType['bound']>,
+  +variance?: ?MaybeDetachedNode<TypeParameterType['variance']>,
+  +default?: ?MaybeDetachedNode<TypeParameterType['default']>,
 };
 
 export type TypeParameterDeclarationProps = {
   +params: $ReadOnlyArray<
-    DetachedNode<TypeParameterDeclarationType['params'][number]>,
+    MaybeDetachedNode<TypeParameterDeclarationType['params'][number]>,
   >,
 };
 
 export type TypeParameterInstantiationProps = {
   +params: $ReadOnlyArray<
-    DetachedNode<TypeParameterInstantiationType['params'][number]>,
+    MaybeDetachedNode<TypeParameterInstantiationType['params'][number]>,
   >,
 };
 
 export type UnaryExpressionProps = {
   +operator: UnaryExpressionType['operator'],
-  +argument: DetachedNode<UnaryExpressionType['argument']>,
+  +argument: MaybeDetachedNode<UnaryExpressionType['argument']>,
   +prefix: UnaryExpressionType['prefix'],
 };
 
 export type UnionTypeAnnotationProps = {
   +types: $ReadOnlyArray<
-    DetachedNode<UnionTypeAnnotationType['types'][number]>,
+    MaybeDetachedNode<UnionTypeAnnotationType['types'][number]>,
   >,
 };
 
 export type UpdateExpressionProps = {
   +operator: UpdateExpressionType['operator'],
-  +argument: DetachedNode<UpdateExpressionType['argument']>,
+  +argument: MaybeDetachedNode<UpdateExpressionType['argument']>,
   +prefix: UpdateExpressionType['prefix'],
 };
 
 export type VariableDeclarationProps = {
   +kind: VariableDeclarationType['kind'],
   +declarations: $ReadOnlyArray<
-    DetachedNode<VariableDeclarationType['declarations'][number]>,
+    MaybeDetachedNode<VariableDeclarationType['declarations'][number]>,
   >,
 };
 
 export type VariableDeclaratorProps = {
-  +init?: ?DetachedNode<VariableDeclaratorType['init']>,
-  +id: DetachedNode<VariableDeclaratorType['id']>,
+  +init?: ?MaybeDetachedNode<VariableDeclaratorType['init']>,
+  +id: MaybeDetachedNode<VariableDeclaratorType['id']>,
 };
 
 export type VarianceProps = {
@@ -974,2125 +969,2100 @@ export type VarianceProps = {
 export type VoidTypeAnnotationProps = {};
 
 export type WhileStatementProps = {
-  +body: DetachedNode<WhileStatementType['body']>,
-  +test: DetachedNode<WhileStatementType['test']>,
+  +body: MaybeDetachedNode<WhileStatementType['body']>,
+  +test: MaybeDetachedNode<WhileStatementType['test']>,
 };
 
 export type WithStatementProps = {
-  +object: DetachedNode<WithStatementType['object']>,
-  +body: DetachedNode<WithStatementType['body']>,
+  +object: MaybeDetachedNode<WithStatementType['object']>,
+  +body: MaybeDetachedNode<WithStatementType['body']>,
 };
 
 export type YieldExpressionProps = {
-  +argument?: ?DetachedNode<YieldExpressionType['argument']>,
+  +argument?: ?MaybeDetachedNode<YieldExpressionType['argument']>,
   +delegate?: ?YieldExpressionType['delegate'],
 };
 
-export function AnyTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<AnyTypeAnnotationType> {
-  return detachedProps<AnyTypeAnnotationType>(parent, {
+export function AnyTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<AnyTypeAnnotationType> {
+  return detachedProps<AnyTypeAnnotationType>(props.parent, {
     type: 'AnyTypeAnnotation',
   });
 }
 
-export function ArrayExpression({
-  parent,
-  ...props
-}: {
+export function ArrayExpression(props: {
   ...$ReadOnly<ArrayExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ArrayExpressionType> {
-  const node = detachedProps<ArrayExpressionType>(parent, {
+  const node = detachedProps<ArrayExpressionType>(props.parent, {
     type: 'ArrayExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    elements: props.elements.map(n => asDetachedNode(n)),
+    trailingComma: props.trailingComma,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ArrayPattern({
-  parent,
-  ...props
-}: {
+export function ArrayPattern(props: {
   ...$ReadOnly<ArrayPatternProps>,
   +parent?: ESNode,
 }): DetachedNode<ArrayPatternType> {
-  const node = detachedProps<ArrayPatternType>(parent, {
+  const node = detachedProps<ArrayPatternType>(props.parent, {
     type: 'ArrayPattern',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    elements: props.elements.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ArrayTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function ArrayTypeAnnotation(props: {
   ...$ReadOnly<ArrayTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<ArrayTypeAnnotationType> {
-  const node = detachedProps<ArrayTypeAnnotationType>(parent, {
+  const node = detachedProps<ArrayTypeAnnotationType>(props.parent, {
     type: 'ArrayTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    elementType: asDetachedNode(props.elementType),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function AssignmentExpression({
-  parent,
-  ...props
-}: {
+export function AssignmentExpression(props: {
   ...$ReadOnly<AssignmentExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<AssignmentExpressionType> {
-  const node = detachedProps<AssignmentExpressionType>(parent, {
+  const node = detachedProps<AssignmentExpressionType>(props.parent, {
     type: 'AssignmentExpression',
-    ...props,
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function AssignmentPattern({
-  parent,
-  ...props
-}: {
+export function AssignmentPattern(props: {
   ...$ReadOnly<AssignmentPatternProps>,
   +parent?: ESNode,
 }): DetachedNode<AssignmentPatternType> {
-  const node = detachedProps<AssignmentPatternType>(parent, {
+  const node = detachedProps<AssignmentPatternType>(props.parent, {
     type: 'AssignmentPattern',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function AwaitExpression({
-  parent,
-  ...props
-}: {
+export function AwaitExpression(props: {
   ...$ReadOnly<AwaitExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<AwaitExpressionType> {
-  const node = detachedProps<AwaitExpressionType>(parent, {
+  const node = detachedProps<AwaitExpressionType>(props.parent, {
     type: 'AwaitExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function BigIntLiteralTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function BigIntLiteralTypeAnnotation(props: {
   ...$ReadOnly<BigIntLiteralTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<BigIntLiteralTypeAnnotationType> {
-  const node = detachedProps<BigIntLiteralTypeAnnotationType>(parent, {
+  const node = detachedProps<BigIntLiteralTypeAnnotationType>(props.parent, {
     type: 'BigIntLiteralTypeAnnotation',
-    ...props,
+    raw: props.raw,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function BinaryExpression({
-  parent,
-  ...props
-}: {
+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>(parent, {
+  const node = detachedProps<BinaryExpressionType>(props.parent, {
     type: 'BinaryExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
+    operator: props.operator,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function BlockStatement({
-  parent,
-  ...props
-}: {
+export function BlockStatement(props: {
   ...$ReadOnly<BlockStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<BlockStatementType> {
-  const node = detachedProps<BlockStatementType>(parent, {
+  const node = detachedProps<BlockStatementType>(props.parent, {
     type: 'BlockStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    body: props.body.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function BooleanLiteralTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function BooleanLiteralTypeAnnotation(props: {
   ...$ReadOnly<BooleanLiteralTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<BooleanLiteralTypeAnnotationType> {
-  const node = detachedProps<BooleanLiteralTypeAnnotationType>(parent, {
+  const node = detachedProps<BooleanLiteralTypeAnnotationType>(props.parent, {
     type: 'BooleanLiteralTypeAnnotation',
-    ...props,
+    value: props.value,
+    raw: props.raw,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function BooleanTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<BooleanTypeAnnotationType> {
-  return detachedProps<BooleanTypeAnnotationType>(parent, {
+export function BooleanTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<BooleanTypeAnnotationType> {
+  return detachedProps<BooleanTypeAnnotationType>(props.parent, {
     type: 'BooleanTypeAnnotation',
   });
 }
 
-export function BreakStatement({
-  parent,
-  ...props
-}: {
+export function BreakStatement(props: {
   ...$ReadOnly<BreakStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<BreakStatementType> {
-  const node = detachedProps<BreakStatementType>(parent, {
+  const node = detachedProps<BreakStatementType>(props.parent, {
     type: 'BreakStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    label: asDetachedNode(props.label),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function CallExpression({
-  parent,
-  ...props
-}: {
+export function CallExpression(props: {
   ...$ReadOnly<CallExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<CallExpressionType> {
-  const node = detachedProps<CallExpressionType>(parent, {
+  const node = detachedProps<CallExpressionType>(props.parent, {
     type: 'CallExpression',
-    ...props,
+    // $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);
   return node;
 }
 
-export function CatchClause({
-  parent,
-  ...props
-}: {
+export function CatchClause(props: {
   ...$ReadOnly<CatchClauseProps>,
   +parent?: ESNode,
 }): DetachedNode<CatchClauseType> {
-  const node = detachedProps<CatchClauseType>(parent, {
+  const node = detachedProps<CatchClauseType>(props.parent, {
     type: 'CatchClause',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    param: asDetachedNode(props.param),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ChainExpression({
-  parent,
-  ...props
-}: {
+export function ChainExpression(props: {
   ...$ReadOnly<ChainExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ChainExpressionType> {
-  const node = detachedProps<ChainExpressionType>(parent, {
+  const node = detachedProps<ChainExpressionType>(props.parent, {
     type: 'ChainExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ClassBody({
-  parent,
-  ...props
-}: {
+export function ClassBody(props: {
   ...$ReadOnly<ClassBodyProps>,
   +parent?: ESNode,
 }): DetachedNode<ClassBodyType> {
-  const node = detachedProps<ClassBodyType>(parent, {
+  const node = detachedProps<ClassBodyType>(props.parent, {
     type: 'ClassBody',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    body: props.body.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ClassDeclaration({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ClassDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<ClassDeclarationType> {
-  const node = detachedProps<ClassDeclarationType>(parent, {
-    type: 'ClassDeclaration',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function ClassExpression({
-  parent,
-  ...props
-}: {
+export function ClassExpression(props: {
   ...$ReadOnly<ClassExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ClassExpressionType> {
-  const node = detachedProps<ClassExpressionType>(parent, {
+  const node = detachedProps<ClassExpressionType>(props.parent, {
     type: 'ClassExpression',
-    ...props,
+    // $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);
   return node;
 }
 
-export function ClassImplements({
-  parent,
-  ...props
-}: {
+export function ClassImplements(props: {
   ...$ReadOnly<ClassImplementsProps>,
   +parent?: ESNode,
 }): DetachedNode<ClassImplementsType> {
-  const node = detachedProps<ClassImplementsType>(parent, {
+  const node = detachedProps<ClassImplementsType>(props.parent, {
     type: 'ClassImplements',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ConditionalExpression({
-  parent,
-  ...props
-}: {
+export function ConditionalExpression(props: {
   ...$ReadOnly<ConditionalExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ConditionalExpressionType> {
-  const node = detachedProps<ConditionalExpressionType>(parent, {
+  const node = detachedProps<ConditionalExpressionType>(props.parent, {
     type: 'ConditionalExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
+    alternate: asDetachedNode(props.alternate),
+    // $FlowFixMe[incompatible-call],
+    consequent: asDetachedNode(props.consequent),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ContinueStatement({
-  parent,
-  ...props
-}: {
+export function ContinueStatement(props: {
   ...$ReadOnly<ContinueStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ContinueStatementType> {
-  const node = detachedProps<ContinueStatementType>(parent, {
+  const node = detachedProps<ContinueStatementType>(props.parent, {
     type: 'ContinueStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    label: asDetachedNode(props.label),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DebuggerStatement({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<DebuggerStatementType> {
-  return detachedProps<DebuggerStatementType>(parent, {
+export function DebuggerStatement(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<DebuggerStatementType> {
+  return detachedProps<DebuggerStatementType>(props.parent, {
     type: 'DebuggerStatement',
   });
 }
 
-export function DeclareClass({
-  parent,
-  ...props
-}: {
+export function DeclareClass(props: {
   ...$ReadOnly<DeclareClassProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareClassType> {
-  const node = detachedProps<DeclareClassType>(parent, {
+  const node = detachedProps<DeclareClassType>(props.parent, {
     type: 'DeclareClass',
-    ...props,
+    // $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);
   return node;
 }
 
-export function DeclaredPredicate({
-  parent,
-  ...props
-}: {
+export function DeclaredPredicate(props: {
   ...$ReadOnly<DeclaredPredicateProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclaredPredicateType> {
-  const node = detachedProps<DeclaredPredicateType>(parent, {
+  const node = detachedProps<DeclaredPredicateType>(props.parent, {
     type: 'DeclaredPredicate',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareExportAllDeclaration({
-  parent,
-  ...props
-}: {
+export function DeclareExportAllDeclaration(props: {
   ...$ReadOnly<DeclareExportAllDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareExportAllDeclarationType> {
-  const node = detachedProps<DeclareExportAllDeclarationType>(parent, {
+  const node = detachedProps<DeclareExportAllDeclarationType>(props.parent, {
     type: 'DeclareExportAllDeclaration',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    source: asDetachedNode(props.source),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareExportDeclaration({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<DeclareExportDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<DeclareExportDeclarationType> {
-  const node = detachedProps<DeclareExportDeclarationType>(parent, {
-    type: 'DeclareExportDeclaration',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function DeclareFunction({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<DeclareFunctionProps>,
-  +parent?: ESNode,
-}): DetachedNode<DeclareFunctionType> {
-  const node = detachedProps<DeclareFunctionType>(parent, {
-    type: 'DeclareFunction',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function DeclareInterface({
-  parent,
-  ...props
-}: {
+export function DeclareInterface(props: {
   ...$ReadOnly<DeclareInterfaceProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareInterfaceType> {
-  const node = detachedProps<DeclareInterfaceType>(parent, {
+  const node = detachedProps<DeclareInterfaceType>(props.parent, {
     type: 'DeclareInterface',
-    ...props,
+    // $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);
   return node;
 }
 
-export function DeclareModule({
-  parent,
-  ...props
-}: {
+export function DeclareModule(props: {
   ...$ReadOnly<DeclareModuleProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareModuleType> {
-  const node = detachedProps<DeclareModuleType>(parent, {
+  const node = detachedProps<DeclareModuleType>(props.parent, {
     type: 'DeclareModule',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
+    kind: props.kind,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareModuleExports({
-  parent,
-  ...props
-}: {
+export function DeclareModuleExports(props: {
   ...$ReadOnly<DeclareModuleExportsProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareModuleExportsType> {
-  const node = detachedProps<DeclareModuleExportsType>(parent, {
+  const node = detachedProps<DeclareModuleExportsType>(props.parent, {
     type: 'DeclareModuleExports',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareOpaqueType({
-  parent,
-  ...props
-}: {
+export function DeclareOpaqueType(props: {
   ...$ReadOnly<DeclareOpaqueTypeProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareOpaqueTypeType> {
-  const node = detachedProps<DeclareOpaqueTypeType>(parent, {
+  const node = detachedProps<DeclareOpaqueTypeType>(props.parent, {
     type: 'DeclareOpaqueType',
-    ...props,
+    // $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);
   return node;
 }
 
-export function DeclareTypeAlias({
-  parent,
-  ...props
-}: {
+export function DeclareTypeAlias(props: {
   ...$ReadOnly<DeclareTypeAliasProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareTypeAliasType> {
-  const node = detachedProps<DeclareTypeAliasType>(parent, {
+  const node = detachedProps<DeclareTypeAliasType>(props.parent, {
     type: 'DeclareTypeAlias',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DeclareVariable({
-  parent,
-  ...props
-}: {
+export function DeclareVariable(props: {
   ...$ReadOnly<DeclareVariableProps>,
   +parent?: ESNode,
 }): DetachedNode<DeclareVariableType> {
-  const node = detachedProps<DeclareVariableType>(parent, {
+  const node = detachedProps<DeclareVariableType>(props.parent, {
     type: 'DeclareVariable',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function DoWhileStatement({
-  parent,
-  ...props
-}: {
+export function DoWhileStatement(props: {
   ...$ReadOnly<DoWhileStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<DoWhileStatementType> {
-  const node = detachedProps<DoWhileStatementType>(parent, {
+  const node = detachedProps<DoWhileStatementType>(props.parent, {
     type: 'DoWhileStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
+    test: asDetachedNode(props.test),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EmptyStatement({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<EmptyStatementType> {
-  return detachedProps<EmptyStatementType>(parent, {
+export function EmptyStatement(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<EmptyStatementType> {
+  return detachedProps<EmptyStatementType>(props.parent, {
     type: 'EmptyStatement',
   });
 }
 
-export function EmptyTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<EmptyTypeAnnotationType> {
-  return detachedProps<EmptyTypeAnnotationType>(parent, {
+export function EmptyTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<EmptyTypeAnnotationType> {
+  return detachedProps<EmptyTypeAnnotationType>(props.parent, {
     type: 'EmptyTypeAnnotation',
   });
 }
 
-export function EnumBooleanBody({
-  parent,
-  ...props
-}: {
+export function EnumBooleanBody(props: {
   ...$ReadOnly<EnumBooleanBodyProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumBooleanBodyType> {
-  const node = detachedProps<EnumBooleanBodyType>(parent, {
+  const node = detachedProps<EnumBooleanBodyType>(props.parent, {
     type: 'EnumBooleanBody',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => asDetachedNode(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumBooleanMember({
-  parent,
-  ...props
-}: {
+export function EnumBooleanMember(props: {
   ...$ReadOnly<EnumBooleanMemberProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumBooleanMemberType> {
-  const node = detachedProps<EnumBooleanMemberType>(parent, {
+  const node = detachedProps<EnumBooleanMemberType>(props.parent, {
     type: 'EnumBooleanMember',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumDeclaration({
-  parent,
-  ...props
-}: {
+export function EnumDeclaration(props: {
   ...$ReadOnly<EnumDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumDeclarationType> {
-  const node = detachedProps<EnumDeclarationType>(parent, {
+  const node = detachedProps<EnumDeclarationType>(props.parent, {
     type: 'EnumDeclaration',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumDefaultedMember({
-  parent,
-  ...props
-}: {
+export function EnumDefaultedMember(props: {
   ...$ReadOnly<EnumDefaultedMemberProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumDefaultedMemberType> {
-  const node = detachedProps<EnumDefaultedMemberType>(parent, {
+  const node = detachedProps<EnumDefaultedMemberType>(props.parent, {
     type: 'EnumDefaultedMember',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumNumberBody({
-  parent,
-  ...props
-}: {
+export function EnumNumberBody(props: {
   ...$ReadOnly<EnumNumberBodyProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumNumberBodyType> {
-  const node = detachedProps<EnumNumberBodyType>(parent, {
+  const node = detachedProps<EnumNumberBodyType>(props.parent, {
     type: 'EnumNumberBody',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => asDetachedNode(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumNumberMember({
-  parent,
-  ...props
-}: {
+export function EnumNumberMember(props: {
   ...$ReadOnly<EnumNumberMemberProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumNumberMemberType> {
-  const node = detachedProps<EnumNumberMemberType>(parent, {
+  const node = detachedProps<EnumNumberMemberType>(props.parent, {
     type: 'EnumNumberMember',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumStringBody({
-  parent,
-  ...props
-}: {
+export function EnumStringBody(props: {
   ...$ReadOnly<EnumStringBodyProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumStringBodyType> {
-  const node = detachedProps<EnumStringBodyType>(parent, {
+  const node = detachedProps<EnumStringBodyType>(props.parent, {
     type: 'EnumStringBody',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => asDetachedNode(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumStringMember({
-  parent,
-  ...props
-}: {
+export function EnumStringMember(props: {
   ...$ReadOnly<EnumStringMemberProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumStringMemberType> {
-  const node = detachedProps<EnumStringMemberType>(parent, {
+  const node = detachedProps<EnumStringMemberType>(props.parent, {
     type: 'EnumStringMember',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: asDetachedNode(props.init),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function EnumSymbolBody({
-  parent,
-  ...props
-}: {
+export function EnumSymbolBody(props: {
   ...$ReadOnly<EnumSymbolBodyProps>,
   +parent?: ESNode,
 }): DetachedNode<EnumSymbolBodyType> {
-  const node = detachedProps<EnumSymbolBodyType>(parent, {
+  const node = detachedProps<EnumSymbolBodyType>(props.parent, {
     type: 'EnumSymbolBody',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => asDetachedNode(n)),
+    hasUnknownMembers: props.hasUnknownMembers,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ExistsTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<ExistsTypeAnnotationType> {
-  return detachedProps<ExistsTypeAnnotationType>(parent, {
+export function ExistsTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<ExistsTypeAnnotationType> {
+  return detachedProps<ExistsTypeAnnotationType>(props.parent, {
     type: 'ExistsTypeAnnotation',
   });
 }
 
-export function ExportAllDeclaration({
-  parent,
-  ...props
-}: {
+export function ExportAllDeclaration(props: {
   ...$ReadOnly<ExportAllDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<ExportAllDeclarationType> {
-  const node = detachedProps<ExportAllDeclarationType>(parent, {
+  const node = detachedProps<ExportAllDeclarationType>(props.parent, {
     type: 'ExportAllDeclaration',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    exported: asDetachedNode(props.exported),
+    // $FlowFixMe[incompatible-call],
+    source: asDetachedNode(props.source),
+    exportKind: props.exportKind,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ExportDefaultDeclaration({
-  parent,
-  ...props
-}: {
+export function ExportDefaultDeclaration(props: {
   ...$ReadOnly<ExportDefaultDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<ExportDefaultDeclarationType> {
-  const node = detachedProps<ExportDefaultDeclarationType>(parent, {
+  const node = detachedProps<ExportDefaultDeclarationType>(props.parent, {
     type: 'ExportDefaultDeclaration',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    declaration: asDetachedNode(props.declaration),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ExportNamedDeclaration({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ExportNamedDeclarationProps>,
-  +parent?: ESNode,
-}): DetachedNode<ExportNamedDeclarationType> {
-  const node = detachedProps<ExportNamedDeclarationType>(parent, {
-    type: 'ExportNamedDeclaration',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function ExportSpecifier({
-  parent,
-  ...props
-}: {
+export function ExportSpecifier(props: {
   ...$ReadOnly<ExportSpecifierProps>,
   +parent?: ESNode,
 }): DetachedNode<ExportSpecifierType> {
-  const node = detachedProps<ExportSpecifierType>(parent, {
+  const node = detachedProps<ExportSpecifierType>(props.parent, {
     type: 'ExportSpecifier',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    exported: asDetachedNode(props.exported),
+    // $FlowFixMe[incompatible-call],
+    local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ExpressionStatement({
-  parent,
-  ...props
-}: {
+export function ExpressionStatement(props: {
   ...$ReadOnly<ExpressionStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ExpressionStatementType> {
-  const node = detachedProps<ExpressionStatementType>(parent, {
+  const node = detachedProps<ExpressionStatementType>(props.parent, {
     type: 'ExpressionStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expression: asDetachedNode(props.expression),
+    directive: props.directive,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ForInStatement({
-  parent,
-  ...props
-}: {
+export function ForInStatement(props: {
   ...$ReadOnly<ForInStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ForInStatementType> {
-  const node = detachedProps<ForInStatementType>(parent, {
+  const node = detachedProps<ForInStatementType>(props.parent, {
     type: 'ForInStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ForOfStatement({
-  parent,
-  ...props
-}: {
+export function ForOfStatement(props: {
   ...$ReadOnly<ForOfStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ForOfStatementType> {
-  const node = detachedProps<ForOfStatementType>(parent, {
+  const node = detachedProps<ForOfStatementType>(props.parent, {
     type: 'ForOfStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
+    await: props.await,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ForStatement({
-  parent,
-  ...props
-}: {
+export function ForStatement(props: {
   ...$ReadOnly<ForStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ForStatementType> {
-  const node = detachedProps<ForStatementType>(parent, {
+  const node = detachedProps<ForStatementType>(props.parent, {
     type: 'ForStatement',
-    ...props,
+    // $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);
   return node;
 }
 
-export function FunctionDeclaration({
-  parent,
-  ...props
-}: {
+export function FunctionDeclaration(props: {
   ...$ReadOnly<FunctionDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<FunctionDeclarationType> {
-  const node = detachedProps<FunctionDeclarationType>(parent, {
+  const node = detachedProps<FunctionDeclarationType>(props.parent, {
     type: 'FunctionDeclaration',
-    ...props,
+    // $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,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function FunctionExpression({
-  parent,
-  ...props
-}: {
+export function FunctionExpression(props: {
   ...$ReadOnly<FunctionExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<FunctionExpressionType> {
-  const node = detachedProps<FunctionExpressionType>(parent, {
+  const node = detachedProps<FunctionExpressionType>(props.parent, {
     type: 'FunctionExpression',
-    ...props,
+    // $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,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function FunctionTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function FunctionTypeAnnotation(props: {
   ...$ReadOnly<FunctionTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<FunctionTypeAnnotationType> {
-  const node = detachedProps<FunctionTypeAnnotationType>(parent, {
+  const node = detachedProps<FunctionTypeAnnotationType>(props.parent, {
     type: 'FunctionTypeAnnotation',
-    ...props,
+    // $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);
   return node;
 }
 
-export function FunctionTypeParam({
-  parent,
-  ...props
-}: {
+export function FunctionTypeParam(props: {
   ...$ReadOnly<FunctionTypeParamProps>,
   +parent?: ESNode,
 }): DetachedNode<FunctionTypeParamType> {
-  const node = detachedProps<FunctionTypeParamType>(parent, {
+  const node = detachedProps<FunctionTypeParamType>(props.parent, {
     type: 'FunctionTypeParam',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
+    optional: props.optional,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function GenericTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function GenericTypeAnnotation(props: {
   ...$ReadOnly<GenericTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<GenericTypeAnnotationType> {
-  const node = detachedProps<GenericTypeAnnotationType>(parent, {
+  const node = detachedProps<GenericTypeAnnotationType>(props.parent, {
     type: 'GenericTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function IfStatement({
-  parent,
-  ...props
-}: {
+export function IfStatement(props: {
   ...$ReadOnly<IfStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<IfStatementType> {
-  const node = detachedProps<IfStatementType>(parent, {
+  const node = detachedProps<IfStatementType>(props.parent, {
     type: 'IfStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
+    consequent: asDetachedNode(props.consequent),
+    // $FlowFixMe[incompatible-call],
+    alternate: asDetachedNode(props.alternate),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportAttribute({
-  parent,
-  ...props
-}: {
+export function ImportAttribute(props: {
   ...$ReadOnly<ImportAttributeProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportAttributeType> {
-  const node = detachedProps<ImportAttributeType>(parent, {
+  const node = detachedProps<ImportAttributeType>(props.parent, {
     type: 'ImportAttribute',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportDeclaration({
-  parent,
-  ...props
-}: {
+export function ImportDeclaration(props: {
   ...$ReadOnly<ImportDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportDeclarationType> {
-  const node = detachedProps<ImportDeclarationType>(parent, {
+  const node = detachedProps<ImportDeclarationType>(props.parent, {
     type: 'ImportDeclaration',
-    ...props,
+    // $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,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportDefaultSpecifier({
-  parent,
-  ...props
-}: {
+export function ImportDefaultSpecifier(props: {
   ...$ReadOnly<ImportDefaultSpecifierProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportDefaultSpecifierType> {
-  const node = detachedProps<ImportDefaultSpecifierType>(parent, {
+  const node = detachedProps<ImportDefaultSpecifierType>(props.parent, {
     type: 'ImportDefaultSpecifier',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportExpression({
-  parent,
-  ...props
-}: {
+export function ImportExpression(props: {
   ...$ReadOnly<ImportExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportExpressionType> {
-  const node = detachedProps<ImportExpressionType>(parent, {
+  const node = detachedProps<ImportExpressionType>(props.parent, {
     type: 'ImportExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    source: asDetachedNode(props.source),
+    // $FlowFixMe[incompatible-call],
+    attributes: asDetachedNode(props.attributes),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportNamespaceSpecifier({
-  parent,
-  ...props
-}: {
+export function ImportNamespaceSpecifier(props: {
   ...$ReadOnly<ImportNamespaceSpecifierProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportNamespaceSpecifierType> {
-  const node = detachedProps<ImportNamespaceSpecifierType>(parent, {
+  const node = detachedProps<ImportNamespaceSpecifierType>(props.parent, {
     type: 'ImportNamespaceSpecifier',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    local: asDetachedNode(props.local),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ImportSpecifier({
-  parent,
-  ...props
-}: {
+export function ImportSpecifier(props: {
   ...$ReadOnly<ImportSpecifierProps>,
   +parent?: ESNode,
 }): DetachedNode<ImportSpecifierType> {
-  const node = detachedProps<ImportSpecifierType>(parent, {
+  const node = detachedProps<ImportSpecifierType>(props.parent, {
     type: 'ImportSpecifier',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    imported: asDetachedNode(props.imported),
+    // $FlowFixMe[incompatible-call],
+    local: asDetachedNode(props.local),
+    importKind: props.importKind,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function IndexedAccessType({
-  parent,
-  ...props
-}: {
+export function IndexedAccessType(props: {
   ...$ReadOnly<IndexedAccessTypeProps>,
   +parent?: ESNode,
 }): DetachedNode<IndexedAccessTypeType> {
-  const node = detachedProps<IndexedAccessTypeType>(parent, {
+  const node = detachedProps<IndexedAccessTypeType>(props.parent, {
     type: 'IndexedAccessType',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    objectType: asDetachedNode(props.objectType),
+    // $FlowFixMe[incompatible-call],
+    indexType: asDetachedNode(props.indexType),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function InferredPredicate({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<InferredPredicateType> {
-  return detachedProps<InferredPredicateType>(parent, {
+export function InferredPredicate(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<InferredPredicateType> {
+  return detachedProps<InferredPredicateType>(props.parent, {
     type: 'InferredPredicate',
   });
 }
 
-export function InterfaceDeclaration({
-  parent,
-  ...props
-}: {
+export function InterfaceDeclaration(props: {
   ...$ReadOnly<InterfaceDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<InterfaceDeclarationType> {
-  const node = detachedProps<InterfaceDeclarationType>(parent, {
+  const node = detachedProps<InterfaceDeclarationType>(props.parent, {
     type: 'InterfaceDeclaration',
-    ...props,
+    // $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);
   return node;
 }
 
-export function InterfaceExtends({
-  parent,
-  ...props
-}: {
+export function InterfaceExtends(props: {
   ...$ReadOnly<InterfaceExtendsProps>,
   +parent?: ESNode,
 }): DetachedNode<InterfaceExtendsType> {
-  const node = detachedProps<InterfaceExtendsType>(parent, {
+  const node = detachedProps<InterfaceExtendsType>(props.parent, {
     type: 'InterfaceExtends',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: asDetachedNode(props.typeParameters),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function InterfaceTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function InterfaceTypeAnnotation(props: {
   ...$ReadOnly<InterfaceTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<InterfaceTypeAnnotationType> {
-  const node = detachedProps<InterfaceTypeAnnotationType>(parent, {
+  const node = detachedProps<InterfaceTypeAnnotationType>(props.parent, {
     type: 'InterfaceTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    extends: props.extends.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function IntersectionTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function IntersectionTypeAnnotation(props: {
   ...$ReadOnly<IntersectionTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<IntersectionTypeAnnotationType> {
-  const node = detachedProps<IntersectionTypeAnnotationType>(parent, {
+  const node = detachedProps<IntersectionTypeAnnotationType>(props.parent, {
     type: 'IntersectionTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXAttribute({
-  parent,
-  ...props
-}: {
+export function JSXAttribute(props: {
   ...$ReadOnly<JSXAttributeProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXAttributeType> {
-  const node = detachedProps<JSXAttributeType>(parent, {
+  const node = detachedProps<JSXAttributeType>(props.parent, {
     type: 'JSXAttribute',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXClosingElement({
-  parent,
-  ...props
-}: {
+export function JSXClosingElement(props: {
   ...$ReadOnly<JSXClosingElementProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXClosingElementType> {
-  const node = detachedProps<JSXClosingElementType>(parent, {
+  const node = detachedProps<JSXClosingElementType>(props.parent, {
     type: 'JSXClosingElement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    name: asDetachedNode(props.name),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXClosingFragment({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<JSXClosingFragmentType> {
-  return detachedProps<JSXClosingFragmentType>(parent, {
+export function JSXClosingFragment(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<JSXClosingFragmentType> {
+  return detachedProps<JSXClosingFragmentType>(props.parent, {
     type: 'JSXClosingFragment',
   });
 }
 
-export function JSXElement({
-  parent,
-  ...props
-}: {
+export function JSXElement(props: {
   ...$ReadOnly<JSXElementProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXElementType> {
-  const node = detachedProps<JSXElementType>(parent, {
+  const node = detachedProps<JSXElementType>(props.parent, {
     type: 'JSXElement',
-    ...props,
+    // $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);
   return node;
 }
 
-export function JSXEmptyExpression({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<JSXEmptyExpressionType> {
-  return detachedProps<JSXEmptyExpressionType>(parent, {
+export function JSXEmptyExpression(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<JSXEmptyExpressionType> {
+  return detachedProps<JSXEmptyExpressionType>(props.parent, {
     type: 'JSXEmptyExpression',
   });
 }
 
-export function JSXExpressionContainer({
-  parent,
-  ...props
-}: {
+export function JSXExpressionContainer(props: {
   ...$ReadOnly<JSXExpressionContainerProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXExpressionContainerType> {
-  const node = detachedProps<JSXExpressionContainerType>(parent, {
+  const node = detachedProps<JSXExpressionContainerType>(props.parent, {
     type: 'JSXExpressionContainer',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXFragment({
-  parent,
-  ...props
-}: {
+export function JSXFragment(props: {
   ...$ReadOnly<JSXFragmentProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXFragmentType> {
-  const node = detachedProps<JSXFragmentType>(parent, {
+  const node = detachedProps<JSXFragmentType>(props.parent, {
     type: 'JSXFragment',
-    ...props,
+    // $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);
   return node;
 }
 
-export function JSXIdentifier({
-  parent,
-  ...props
-}: {
+export function JSXIdentifier(props: {
   ...$ReadOnly<JSXIdentifierProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXIdentifierType> {
-  const node = detachedProps<JSXIdentifierType>(parent, {
+  const node = detachedProps<JSXIdentifierType>(props.parent, {
     type: 'JSXIdentifier',
-    ...props,
+    name: props.name,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXMemberExpression({
-  parent,
-  ...props
-}: {
+export function JSXMemberExpression(props: {
   ...$ReadOnly<JSXMemberExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXMemberExpressionType> {
-  const node = detachedProps<JSXMemberExpressionType>(parent, {
+  const node = detachedProps<JSXMemberExpressionType>(props.parent, {
     type: 'JSXMemberExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
+    property: asDetachedNode(props.property),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXNamespacedName({
-  parent,
-  ...props
-}: {
+export function JSXNamespacedName(props: {
   ...$ReadOnly<JSXNamespacedNameProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXNamespacedNameType> {
-  const node = detachedProps<JSXNamespacedNameType>(parent, {
+  const node = detachedProps<JSXNamespacedNameType>(props.parent, {
     type: 'JSXNamespacedName',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    namespace: asDetachedNode(props.namespace),
+    // $FlowFixMe[incompatible-call],
+    name: asDetachedNode(props.name),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXOpeningElement({
-  parent,
-  ...props
-}: {
+export function JSXOpeningElement(props: {
   ...$ReadOnly<JSXOpeningElementProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXOpeningElementType> {
-  const node = detachedProps<JSXOpeningElementType>(parent, {
+  const node = detachedProps<JSXOpeningElementType>(props.parent, {
     type: 'JSXOpeningElement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    name: asDetachedNode(props.name),
+    // $FlowFixMe[incompatible-call],
+    attributes: props.attributes.map(n => asDetachedNode(n)),
+    selfClosing: props.selfClosing,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXOpeningFragment({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<JSXOpeningFragmentType> {
-  return detachedProps<JSXOpeningFragmentType>(parent, {
+export function JSXOpeningFragment(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<JSXOpeningFragmentType> {
+  return detachedProps<JSXOpeningFragmentType>(props.parent, {
     type: 'JSXOpeningFragment',
   });
 }
 
-export function JSXSpreadAttribute({
-  parent,
-  ...props
-}: {
+export function JSXSpreadAttribute(props: {
   ...$ReadOnly<JSXSpreadAttributeProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXSpreadAttributeType> {
-  const node = detachedProps<JSXSpreadAttributeType>(parent, {
+  const node = detachedProps<JSXSpreadAttributeType>(props.parent, {
     type: 'JSXSpreadAttribute',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXSpreadChild({
-  parent,
-  ...props
-}: {
+export function JSXSpreadChild(props: {
   ...$ReadOnly<JSXSpreadChildProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXSpreadChildType> {
-  const node = detachedProps<JSXSpreadChildType>(parent, {
+  const node = detachedProps<JSXSpreadChildType>(props.parent, {
     type: 'JSXSpreadChild',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expression: asDetachedNode(props.expression),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function JSXText({
-  parent,
-  ...props
-}: {
+export function JSXText(props: {
   ...$ReadOnly<JSXTextProps>,
   +parent?: ESNode,
 }): DetachedNode<JSXTextType> {
-  const node = detachedProps<JSXTextType>(parent, {
+  const node = detachedProps<JSXTextType>(props.parent, {
     type: 'JSXText',
-    ...props,
+    value: props.value,
+    raw: props.raw,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function LabeledStatement({
-  parent,
-  ...props
-}: {
+export function LabeledStatement(props: {
   ...$ReadOnly<LabeledStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<LabeledStatementType> {
-  const node = detachedProps<LabeledStatementType>(parent, {
+  const node = detachedProps<LabeledStatementType>(props.parent, {
     type: 'LabeledStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    label: asDetachedNode(props.label),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function LogicalExpression({
-  parent,
-  ...props
-}: {
+export function LogicalExpression(props: {
   ...$ReadOnly<LogicalExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<LogicalExpressionType> {
-  const node = detachedProps<LogicalExpressionType>(parent, {
+  const node = detachedProps<LogicalExpressionType>(props.parent, {
     type: 'LogicalExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    left: asDetachedNode(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
+    operator: props.operator,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function MemberExpression({
-  parent,
-  ...props
-}: {
+export function MemberExpression(props: {
   ...$ReadOnly<MemberExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<MemberExpressionType> {
-  const node = detachedProps<MemberExpressionType>(parent, {
+  const node = detachedProps<MemberExpressionType>(props.parent, {
     type: 'MemberExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
+    property: asDetachedNode(props.property),
+    computed: props.computed,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function MetaProperty({
-  parent,
-  ...props
-}: {
+export function MetaProperty(props: {
   ...$ReadOnly<MetaPropertyProps>,
   +parent?: ESNode,
 }): DetachedNode<MetaPropertyType> {
-  const node = detachedProps<MetaPropertyType>(parent, {
+  const node = detachedProps<MetaPropertyType>(props.parent, {
     type: 'MetaProperty',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    meta: asDetachedNode(props.meta),
+    // $FlowFixMe[incompatible-call],
+    property: asDetachedNode(props.property),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function MethodDefinition({
-  parent,
-  ...props
-}: {
+export function MethodDefinition(props: {
   ...$ReadOnly<MethodDefinitionProps>,
   +parent?: ESNode,
 }): DetachedNode<MethodDefinitionType> {
-  const node = detachedProps<MethodDefinitionType>(parent, {
+  const node = detachedProps<MethodDefinitionType>(props.parent, {
     type: 'MethodDefinition',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
+    kind: props.kind,
+    computed: props.computed,
+    static: props.static,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function MixedTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<MixedTypeAnnotationType> {
-  return detachedProps<MixedTypeAnnotationType>(parent, {
+export function MixedTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<MixedTypeAnnotationType> {
+  return detachedProps<MixedTypeAnnotationType>(props.parent, {
     type: 'MixedTypeAnnotation',
   });
 }
 
-export function NewExpression({
-  parent,
-  ...props
-}: {
+export function NewExpression(props: {
   ...$ReadOnly<NewExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<NewExpressionType> {
-  const node = detachedProps<NewExpressionType>(parent, {
+  const node = detachedProps<NewExpressionType>(props.parent, {
     type: 'NewExpression',
-    ...props,
+    // $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);
   return node;
 }
 
-export function NullableTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function NullableTypeAnnotation(props: {
   ...$ReadOnly<NullableTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<NullableTypeAnnotationType> {
-  const node = detachedProps<NullableTypeAnnotationType>(parent, {
+  const node = detachedProps<NullableTypeAnnotationType>(props.parent, {
     type: 'NullableTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function NullLiteralTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<NullLiteralTypeAnnotationType> {
-  return detachedProps<NullLiteralTypeAnnotationType>(parent, {
+export function NullLiteralTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<NullLiteralTypeAnnotationType> {
+  return detachedProps<NullLiteralTypeAnnotationType>(props.parent, {
     type: 'NullLiteralTypeAnnotation',
   });
 }
 
-export function NumberLiteralTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function NumberLiteralTypeAnnotation(props: {
   ...$ReadOnly<NumberLiteralTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<NumberLiteralTypeAnnotationType> {
-  const node = detachedProps<NumberLiteralTypeAnnotationType>(parent, {
+  const node = detachedProps<NumberLiteralTypeAnnotationType>(props.parent, {
     type: 'NumberLiteralTypeAnnotation',
-    ...props,
+    value: props.value,
+    raw: props.raw,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function NumberTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<NumberTypeAnnotationType> {
-  return detachedProps<NumberTypeAnnotationType>(parent, {
+export function NumberTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<NumberTypeAnnotationType> {
+  return detachedProps<NumberTypeAnnotationType>(props.parent, {
     type: 'NumberTypeAnnotation',
   });
 }
 
-export function ObjectExpression({
-  parent,
-  ...props
-}: {
+export function ObjectExpression(props: {
   ...$ReadOnly<ObjectExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectExpressionType> {
-  const node = detachedProps<ObjectExpressionType>(parent, {
+  const node = detachedProps<ObjectExpressionType>(props.parent, {
     type: 'ObjectExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    properties: props.properties.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ObjectPattern({
-  parent,
-  ...props
-}: {
+export function ObjectPattern(props: {
   ...$ReadOnly<ObjectPatternProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectPatternType> {
-  const node = detachedProps<ObjectPatternType>(parent, {
+  const node = detachedProps<ObjectPatternType>(props.parent, {
     type: 'ObjectPattern',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    properties: props.properties.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ObjectTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function ObjectTypeAnnotation(props: {
   ...$ReadOnly<ObjectTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeAnnotationType> {
-  const node = detachedProps<ObjectTypeAnnotationType>(parent, {
+  const node = detachedProps<ObjectTypeAnnotationType>(props.parent, {
     type: 'ObjectTypeAnnotation',
-    ...props,
+    // $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,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ObjectTypeCallProperty({
-  parent,
-  ...props
-}: {
+export function ObjectTypeCallProperty(props: {
   ...$ReadOnly<ObjectTypeCallPropertyProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeCallPropertyType> {
-  const node = detachedProps<ObjectTypeCallPropertyType>(parent, {
+  const node = detachedProps<ObjectTypeCallPropertyType>(props.parent, {
     type: 'ObjectTypeCallProperty',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
+    static: props.static,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ObjectTypeIndexer({
-  parent,
-  ...props
-}: {
+export function ObjectTypeIndexer(props: {
   ...$ReadOnly<ObjectTypeIndexerProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeIndexerType> {
-  const node = detachedProps<ObjectTypeIndexerType>(parent, {
+  const node = detachedProps<ObjectTypeIndexerType>(props.parent, {
     type: 'ObjectTypeIndexer',
-    ...props,
+    // $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);
   return node;
 }
 
-export function ObjectTypeInternalSlot({
-  parent,
-  ...props
-}: {
+export function ObjectTypeInternalSlot(props: {
   ...$ReadOnly<ObjectTypeInternalSlotProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeInternalSlotType> {
-  const node = detachedProps<ObjectTypeInternalSlotType>(parent, {
+  const node = detachedProps<ObjectTypeInternalSlotType>(props.parent, {
     type: 'ObjectTypeInternalSlot',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
+    optional: props.optional,
+    static: props.static,
+    method: props.method,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ObjectTypeProperty({
-  parent,
-  ...props
-}: {
-  ...$ReadOnly<ObjectTypePropertyProps>,
-  +parent?: ESNode,
-}): DetachedNode<ObjectTypePropertyType> {
-  const node = detachedProps<ObjectTypePropertyType>(parent, {
-    type: 'ObjectTypeProperty',
-    ...props,
-  });
-  setParentPointersInDirectChildren(node);
-  return node;
-}
-
-export function ObjectTypeSpreadProperty({
-  parent,
-  ...props
-}: {
+export function ObjectTypeSpreadProperty(props: {
   ...$ReadOnly<ObjectTypeSpreadPropertyProps>,
   +parent?: ESNode,
 }): DetachedNode<ObjectTypeSpreadPropertyType> {
-  const node = detachedProps<ObjectTypeSpreadPropertyType>(parent, {
+  const node = detachedProps<ObjectTypeSpreadPropertyType>(props.parent, {
     type: 'ObjectTypeSpreadProperty',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function OpaqueType({
-  parent,
-  ...props
-}: {
+export function OpaqueType(props: {
   ...$ReadOnly<OpaqueTypeProps>,
   +parent?: ESNode,
 }): DetachedNode<OpaqueTypeType> {
-  const node = detachedProps<OpaqueTypeType>(parent, {
+  const node = detachedProps<OpaqueTypeType>(props.parent, {
     type: 'OpaqueType',
-    ...props,
+    // $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);
   return node;
 }
 
-export function OptionalIndexedAccessType({
-  parent,
-  ...props
-}: {
+export function OptionalIndexedAccessType(props: {
   ...$ReadOnly<OptionalIndexedAccessTypeProps>,
   +parent?: ESNode,
 }): DetachedNode<OptionalIndexedAccessTypeType> {
-  const node = detachedProps<OptionalIndexedAccessTypeType>(parent, {
+  const node = detachedProps<OptionalIndexedAccessTypeType>(props.parent, {
     type: 'OptionalIndexedAccessType',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    objectType: asDetachedNode(props.objectType),
+    // $FlowFixMe[incompatible-call],
+    indexType: asDetachedNode(props.indexType),
+    optional: props.optional,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function PrivateIdentifier({
-  parent,
-  ...props
-}: {
+export function PrivateIdentifier(props: {
   ...$ReadOnly<PrivateIdentifierProps>,
   +parent?: ESNode,
 }): DetachedNode<PrivateIdentifierType> {
-  const node = detachedProps<PrivateIdentifierType>(parent, {
+  const node = detachedProps<PrivateIdentifierType>(props.parent, {
     type: 'PrivateIdentifier',
-    ...props,
+    name: props.name,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function Property({
-  parent,
-  ...props
-}: {
+export function Property(props: {
   ...$ReadOnly<PropertyProps>,
   +parent?: ESNode,
 }): DetachedNode<PropertyType> {
-  const node = detachedProps<PropertyType>(parent, {
+  const node = detachedProps<PropertyType>(props.parent, {
     type: 'Property',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    key: asDetachedNode(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: asDetachedNode(props.value),
+    kind: props.kind,
+    computed: props.computed,
+    method: props.method,
+    shorthand: props.shorthand,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function PropertyDefinition({
-  parent,
-  ...props
-}: {
+export function PropertyDefinition(props: {
   ...$ReadOnly<PropertyDefinitionProps>,
   +parent?: ESNode,
 }): DetachedNode<PropertyDefinitionType> {
-  const node = detachedProps<PropertyDefinitionType>(parent, {
+  const node = detachedProps<PropertyDefinitionType>(props.parent, {
     type: 'PropertyDefinition',
-    ...props,
+    // $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;
 }
 
-export function QualifiedTypeIdentifier({
-  parent,
-  ...props
-}: {
+export function QualifiedTypeIdentifier(props: {
   ...$ReadOnly<QualifiedTypeIdentifierProps>,
   +parent?: ESNode,
 }): DetachedNode<QualifiedTypeIdentifierType> {
-  const node = detachedProps<QualifiedTypeIdentifierType>(parent, {
+  const node = detachedProps<QualifiedTypeIdentifierType>(props.parent, {
     type: 'QualifiedTypeIdentifier',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    qualification: asDetachedNode(props.qualification),
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function RestElement({
-  parent,
-  ...props
-}: {
+export function RestElement(props: {
   ...$ReadOnly<RestElementProps>,
   +parent?: ESNode,
 }): DetachedNode<RestElementType> {
-  const node = detachedProps<RestElementType>(parent, {
+  const node = detachedProps<RestElementType>(props.parent, {
     type: 'RestElement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ReturnStatement({
-  parent,
-  ...props
-}: {
+export function ReturnStatement(props: {
   ...$ReadOnly<ReturnStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ReturnStatementType> {
-  const node = detachedProps<ReturnStatementType>(parent, {
+  const node = detachedProps<ReturnStatementType>(props.parent, {
     type: 'ReturnStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function SequenceExpression({
-  parent,
-  ...props
-}: {
+export function SequenceExpression(props: {
   ...$ReadOnly<SequenceExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<SequenceExpressionType> {
-  const node = detachedProps<SequenceExpressionType>(parent, {
+  const node = detachedProps<SequenceExpressionType>(props.parent, {
     type: 'SequenceExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expressions: props.expressions.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function SpreadElement({
-  parent,
-  ...props
-}: {
+export function SpreadElement(props: {
   ...$ReadOnly<SpreadElementProps>,
   +parent?: ESNode,
 }): DetachedNode<SpreadElementType> {
-  const node = detachedProps<SpreadElementType>(parent, {
+  const node = detachedProps<SpreadElementType>(props.parent, {
     type: 'SpreadElement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function StringLiteralTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function StringLiteralTypeAnnotation(props: {
   ...$ReadOnly<StringLiteralTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<StringLiteralTypeAnnotationType> {
-  const node = detachedProps<StringLiteralTypeAnnotationType>(parent, {
+  const node = detachedProps<StringLiteralTypeAnnotationType>(props.parent, {
     type: 'StringLiteralTypeAnnotation',
-    ...props,
+    value: props.value,
+    raw: props.raw,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function StringTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<StringTypeAnnotationType> {
-  return detachedProps<StringTypeAnnotationType>(parent, {
+export function StringTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<StringTypeAnnotationType> {
+  return detachedProps<StringTypeAnnotationType>(props.parent, {
     type: 'StringTypeAnnotation',
   });
 }
 
-export function Super({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<SuperType> {
-  return detachedProps<SuperType>(parent, {
+export function Super(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<SuperType> {
+  return detachedProps<SuperType>(props.parent, {
     type: 'Super',
   });
 }
 
-export function SwitchCase({
-  parent,
-  ...props
-}: {
+export function SwitchCase(props: {
   ...$ReadOnly<SwitchCaseProps>,
   +parent?: ESNode,
 }): DetachedNode<SwitchCaseType> {
-  const node = detachedProps<SwitchCaseType>(parent, {
+  const node = detachedProps<SwitchCaseType>(props.parent, {
     type: 'SwitchCase',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    test: asDetachedNode(props.test),
+    // $FlowFixMe[incompatible-call],
+    consequent: props.consequent.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function SwitchStatement({
-  parent,
-  ...props
-}: {
+export function SwitchStatement(props: {
   ...$ReadOnly<SwitchStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<SwitchStatementType> {
-  const node = detachedProps<SwitchStatementType>(parent, {
+  const node = detachedProps<SwitchStatementType>(props.parent, {
     type: 'SwitchStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    discriminant: asDetachedNode(props.discriminant),
+    // $FlowFixMe[incompatible-call],
+    cases: props.cases.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function SymbolTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<SymbolTypeAnnotationType> {
-  return detachedProps<SymbolTypeAnnotationType>(parent, {
+export function SymbolTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<SymbolTypeAnnotationType> {
+  return detachedProps<SymbolTypeAnnotationType>(props.parent, {
     type: 'SymbolTypeAnnotation',
   });
 }
 
-export function TaggedTemplateExpression({
-  parent,
-  ...props
-}: {
+export function TaggedTemplateExpression(props: {
   ...$ReadOnly<TaggedTemplateExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<TaggedTemplateExpressionType> {
-  const node = detachedProps<TaggedTemplateExpressionType>(parent, {
+  const node = detachedProps<TaggedTemplateExpressionType>(props.parent, {
     type: 'TaggedTemplateExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    tag: asDetachedNode(props.tag),
+    // $FlowFixMe[incompatible-call],
+    quasi: asDetachedNode(props.quasi),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TemplateLiteral({
-  parent,
-  ...props
-}: {
+export function TemplateLiteral(props: {
   ...$ReadOnly<TemplateLiteralProps>,
   +parent?: ESNode,
 }): DetachedNode<TemplateLiteralType> {
-  const node = detachedProps<TemplateLiteralType>(parent, {
+  const node = detachedProps<TemplateLiteralType>(props.parent, {
     type: 'TemplateLiteral',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    quasis: props.quasis.map(n => asDetachedNode(n)),
+    // $FlowFixMe[incompatible-call],
+    expressions: props.expressions.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function ThisExpression({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<ThisExpressionType> {
-  return detachedProps<ThisExpressionType>(parent, {
+export function ThisExpression(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<ThisExpressionType> {
+  return detachedProps<ThisExpressionType>(props.parent, {
     type: 'ThisExpression',
   });
 }
 
-export function ThisTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<ThisTypeAnnotationType> {
-  return detachedProps<ThisTypeAnnotationType>(parent, {
+export function ThisTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<ThisTypeAnnotationType> {
+  return detachedProps<ThisTypeAnnotationType>(props.parent, {
     type: 'ThisTypeAnnotation',
   });
 }
 
-export function ThrowStatement({
-  parent,
-  ...props
-}: {
+export function ThrowStatement(props: {
   ...$ReadOnly<ThrowStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<ThrowStatementType> {
-  const node = detachedProps<ThrowStatementType>(parent, {
+  const node = detachedProps<ThrowStatementType>(props.parent, {
     type: 'ThrowStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TryStatement({
-  parent,
-  ...props
-}: {
+export function TryStatement(props: {
   ...$ReadOnly<TryStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<TryStatementType> {
-  const node = detachedProps<TryStatementType>(parent, {
+  const node = detachedProps<TryStatementType>(props.parent, {
     type: 'TryStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    block: asDetachedNode(props.block),
+    // $FlowFixMe[incompatible-call],
+    handler: asDetachedNode(props.handler),
+    // $FlowFixMe[incompatible-call],
+    finalizer: asDetachedNode(props.finalizer),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TupleTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function TupleTypeAnnotation(props: {
   ...$ReadOnly<TupleTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<TupleTypeAnnotationType> {
-  const node = detachedProps<TupleTypeAnnotationType>(parent, {
+  const node = detachedProps<TupleTypeAnnotationType>(props.parent, {
     type: 'TupleTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeAlias({
-  parent,
-  ...props
-}: {
+export function TypeAlias(props: {
   ...$ReadOnly<TypeAliasProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeAliasType> {
-  const node = detachedProps<TypeAliasType>(parent, {
+  const node = detachedProps<TypeAliasType>(props.parent, {
     type: 'TypeAlias',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: asDetachedNode(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    right: asDetachedNode(props.right),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeAnnotation({
-  parent,
-  ...props
-}: {
+export function TypeAnnotation(props: {
   ...$ReadOnly<TypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeAnnotationType> {
-  const node = detachedProps<TypeAnnotationType>(parent, {
+  const node = detachedProps<TypeAnnotationType>(props.parent, {
     type: 'TypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeCastExpression({
-  parent,
-  ...props
-}: {
+export function TypeCastExpression(props: {
   ...$ReadOnly<TypeCastExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeCastExpressionType> {
-  const node = detachedProps<TypeCastExpressionType>(parent, {
+  const node = detachedProps<TypeCastExpressionType>(props.parent, {
     type: 'TypeCastExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    expression: asDetachedNode(props.expression),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: asDetachedNode(props.typeAnnotation),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeofTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function TypeofTypeAnnotation(props: {
   ...$ReadOnly<TypeofTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeofTypeAnnotationType> {
-  const node = detachedProps<TypeofTypeAnnotationType>(parent, {
+  const node = detachedProps<TypeofTypeAnnotationType>(props.parent, {
     type: 'TypeofTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeParameter({
-  parent,
-  ...props
-}: {
+export function TypeParameter(props: {
   ...$ReadOnly<TypeParameterProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeParameterType> {
-  const node = detachedProps<TypeParameterType>(parent, {
+  const node = detachedProps<TypeParameterType>(props.parent, {
     type: 'TypeParameter',
-    ...props,
+    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);
   return node;
 }
 
-export function TypeParameterDeclaration({
-  parent,
-  ...props
-}: {
+export function TypeParameterDeclaration(props: {
   ...$ReadOnly<TypeParameterDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeParameterDeclarationType> {
-  const node = detachedProps<TypeParameterDeclarationType>(parent, {
+  const node = detachedProps<TypeParameterDeclarationType>(props.parent, {
     type: 'TypeParameterDeclaration',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function TypeParameterInstantiation({
-  parent,
-  ...props
-}: {
+export function TypeParameterInstantiation(props: {
   ...$ReadOnly<TypeParameterInstantiationProps>,
   +parent?: ESNode,
 }): DetachedNode<TypeParameterInstantiationType> {
-  const node = detachedProps<TypeParameterInstantiationType>(parent, {
+  const node = detachedProps<TypeParameterInstantiationType>(props.parent, {
     type: 'TypeParameterInstantiation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function UnaryExpression({
-  parent,
-  ...props
-}: {
+export function UnaryExpression(props: {
   ...$ReadOnly<UnaryExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<UnaryExpressionType> {
-  const node = detachedProps<UnaryExpressionType>(parent, {
+  const node = detachedProps<UnaryExpressionType>(props.parent, {
     type: 'UnaryExpression',
-    ...props,
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
+    prefix: props.prefix,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function UnionTypeAnnotation({
-  parent,
-  ...props
-}: {
+export function UnionTypeAnnotation(props: {
   ...$ReadOnly<UnionTypeAnnotationProps>,
   +parent?: ESNode,
 }): DetachedNode<UnionTypeAnnotationType> {
-  const node = detachedProps<UnionTypeAnnotationType>(parent, {
+  const node = detachedProps<UnionTypeAnnotationType>(props.parent, {
     type: 'UnionTypeAnnotation',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function UpdateExpression({
-  parent,
-  ...props
-}: {
+export function UpdateExpression(props: {
   ...$ReadOnly<UpdateExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<UpdateExpressionType> {
-  const node = detachedProps<UpdateExpressionType>(parent, {
+  const node = detachedProps<UpdateExpressionType>(props.parent, {
     type: 'UpdateExpression',
-    ...props,
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
+    prefix: props.prefix,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function VariableDeclaration({
-  parent,
-  ...props
-}: {
+export function VariableDeclaration(props: {
   ...$ReadOnly<VariableDeclarationProps>,
   +parent?: ESNode,
 }): DetachedNode<VariableDeclarationType> {
-  const node = detachedProps<VariableDeclarationType>(parent, {
+  const node = detachedProps<VariableDeclarationType>(props.parent, {
     type: 'VariableDeclaration',
-    ...props,
+    kind: props.kind,
+    // $FlowFixMe[incompatible-call],
+    declarations: props.declarations.map(n => asDetachedNode(n)),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function VariableDeclarator({
-  parent,
-  ...props
-}: {
+export function VariableDeclarator(props: {
   ...$ReadOnly<VariableDeclaratorProps>,
   +parent?: ESNode,
 }): DetachedNode<VariableDeclaratorType> {
-  const node = detachedProps<VariableDeclaratorType>(parent, {
+  const node = detachedProps<VariableDeclaratorType>(props.parent, {
     type: 'VariableDeclarator',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    init: asDetachedNode(props.init),
+    // $FlowFixMe[incompatible-call],
+    id: asDetachedNode(props.id),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function Variance({
-  parent,
-  ...props
-}: {
+export function Variance(props: {
   ...$ReadOnly<VarianceProps>,
   +parent?: ESNode,
 }): DetachedNode<VarianceType> {
-  const node = detachedProps<VarianceType>(parent, {
+  const node = detachedProps<VarianceType>(props.parent, {
     type: 'Variance',
-    ...props,
+    kind: props.kind,
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function VoidTypeAnnotation({
-  parent,
-}: {
-  +parent?: ESNode,
-} = {}): DetachedNode<VoidTypeAnnotationType> {
-  return detachedProps<VoidTypeAnnotationType>(parent, {
+export function VoidTypeAnnotation(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<VoidTypeAnnotationType> {
+  return detachedProps<VoidTypeAnnotationType>(props.parent, {
     type: 'VoidTypeAnnotation',
   });
 }
 
-export function WhileStatement({
-  parent,
-  ...props
-}: {
+export function WhileStatement(props: {
   ...$ReadOnly<WhileStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<WhileStatementType> {
-  const node = detachedProps<WhileStatementType>(parent, {
+  const node = detachedProps<WhileStatementType>(props.parent, {
     type: 'WhileStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
+    // $FlowFixMe[incompatible-call],
+    test: asDetachedNode(props.test),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function WithStatement({
-  parent,
-  ...props
-}: {
+export function WithStatement(props: {
   ...$ReadOnly<WithStatementProps>,
   +parent?: ESNode,
 }): DetachedNode<WithStatementType> {
-  const node = detachedProps<WithStatementType>(parent, {
+  const node = detachedProps<WithStatementType>(props.parent, {
     type: 'WithStatement',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    object: asDetachedNode(props.object),
+    // $FlowFixMe[incompatible-call],
+    body: asDetachedNode(props.body),
   });
   setParentPointersInDirectChildren(node);
   return node;
 }
 
-export function YieldExpression({
-  parent,
-  ...props
-}: {
+export function YieldExpression(props: {
   ...$ReadOnly<YieldExpressionProps>,
   +parent?: ESNode,
 }): DetachedNode<YieldExpressionType> {
-  const node = detachedProps<YieldExpressionType>(parent, {
+  const node = detachedProps<YieldExpressionType>(props.parent, {
     type: 'YieldExpression',
-    ...props,
+    // $FlowFixMe[incompatible-call],
+    argument: asDetachedNode(props.argument),
+    delegate: props.delegate,
   });
   setParentPointersInDirectChildren(node);
   return node;