hermes-transform 0.8.0 → 0.10.0

package/dist/generated/node-types.js

@@ -6,6 +6,13 @@
  *
  * 
  * @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
 
@@ -26,6 +33,7 @@ var _exportNames = {
   AssignmentPattern: true,
   AwaitExpression: true,
   BigIntLiteralTypeAnnotation: true,
+  BigIntTypeAnnotation: true,
   BinaryExpression: true,
   BlockStatement: true,
   BooleanLiteralTypeAnnotation: true,
@@ -35,7 +43,6 @@ var _exportNames = {
   CatchClause: true,
   ChainExpression: true,
   ClassBody: true,
-  ClassDeclaration: true,
   ClassExpression: true,
   ClassImplements: true,
   ConditionalExpression: true,
@@ -44,8 +51,6 @@ var _exportNames = {
   DeclareClass: true,
   DeclaredPredicate: true,
   DeclareExportAllDeclaration: true,
-  DeclareExportDeclaration: true,
-  DeclareFunction: true,
   DeclareInterface: true,
   DeclareModule: true,
   DeclareModuleExports: true,
@@ -67,7 +72,6 @@ var _exportNames = {
   ExistsTypeAnnotation: true,
   ExportAllDeclaration: true,
   ExportDefaultDeclaration: true,
-  ExportNamedDeclaration: true,
   ExportSpecifier: true,
   ExpressionStatement: true,
   ForInStatement: true,
@@ -123,7 +127,6 @@ var _exportNames = {
   ObjectTypeCallProperty: true,
   ObjectTypeIndexer: true,
   ObjectTypeInternalSlot: true,
-  ObjectTypeProperty: true,
   ObjectTypeSpreadProperty: true,
   OpaqueType: true,
   OptionalIndexedAccessType: true,
@@ -174,6 +177,7 @@ exports.AssignmentExpression = AssignmentExpression;
 exports.AssignmentPattern = AssignmentPattern;
 exports.AwaitExpression = AwaitExpression;
 exports.BigIntLiteralTypeAnnotation = BigIntLiteralTypeAnnotation;
+exports.BigIntTypeAnnotation = BigIntTypeAnnotation;
 exports.BinaryExpression = BinaryExpression;
 exports.BlockStatement = BlockStatement;
 exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
@@ -183,7 +187,6 @@ exports.CallExpression = CallExpression;
 exports.CatchClause = CatchClause;
 exports.ChainExpression = ChainExpression;
 exports.ClassBody = ClassBody;
-exports.ClassDeclaration = ClassDeclaration;
 exports.ClassExpression = ClassExpression;
 exports.ClassImplements = ClassImplements;
 exports.ConditionalExpression = ConditionalExpression;
@@ -191,8 +194,6 @@ exports.ContinueStatement = ContinueStatement;
 exports.DebuggerStatement = DebuggerStatement;
 exports.DeclareClass = DeclareClass;
 exports.DeclareExportAllDeclaration = DeclareExportAllDeclaration;
-exports.DeclareExportDeclaration = DeclareExportDeclaration;
-exports.DeclareFunction = DeclareFunction;
 exports.DeclareInterface = DeclareInterface;
 exports.DeclareModule = DeclareModule;
 exports.DeclareModuleExports = DeclareModuleExports;
@@ -215,7 +216,6 @@ exports.EnumSymbolBody = EnumSymbolBody;
 exports.ExistsTypeAnnotation = ExistsTypeAnnotation;
 exports.ExportAllDeclaration = ExportAllDeclaration;
 exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
-exports.ExportNamedDeclaration = ExportNamedDeclaration;
 exports.ExportSpecifier = ExportSpecifier;
 exports.ExpressionStatement = ExpressionStatement;
 exports.ForInStatement = ForInStatement;
@@ -271,7 +271,6 @@ exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
 exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
 exports.ObjectTypeIndexer = ObjectTypeIndexer;
 exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
-exports.ObjectTypeProperty = ObjectTypeProperty;
 exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
 exports.OpaqueType = OpaqueType;
 exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
@@ -325,1689 +324,1659 @@ Object.keys(_specialCaseNodeTypes).forEach(function (key) {
   exports[key] = _specialCaseNodeTypes[key];
 });
 
-function AnyTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function AnyTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'AnyTypeAnnotation'
   });
 }
 
-function ArrayExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ArrayExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ArrayExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    elements: props.elements.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    trailingComma: props.trailingComma
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ArrayPattern({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ArrayPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ArrayPattern',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    elements: props.elements.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ArrayTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ArrayTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ArrayTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    elementType: (0, _detachedNode.asDetachedNode)(props.elementType)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function AssignmentExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function AssignmentExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'AssignmentExpression',
-    ...props
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function AssignmentPattern({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function AssignmentPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'AssignmentPattern',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function AwaitExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function AwaitExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'AwaitExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function BigIntLiteralTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function BigIntLiteralTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BigIntLiteralTypeAnnotation',
-    ...props
+    raw: props.raw
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function BinaryExpression({
-  parent,
-  ...props
+function BigIntTypeAnnotation(props = { ...null
 }) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'BigIntTypeAnnotation'
+  });
+}
+
+function BinaryExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BinaryExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right),
+    operator: props.operator
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function BlockStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function BlockStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BlockStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function BooleanLiteralTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function BooleanLiteralTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BooleanLiteralTypeAnnotation',
-    ...props
+    value: props.value,
+    raw: props.raw
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function BooleanTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function BooleanTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BooleanTypeAnnotation'
   });
 }
 
-function BreakStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function BreakStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'BreakStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    label: (0, _detachedNode.asDetachedNode)(props.label)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function CallExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function CallExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'CallExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    callee: (0, _detachedNode.asDetachedNode)(props.callee),
+    // $FlowFixMe[incompatible-call],
+    typeArguments: (0, _detachedNode.asDetachedNode)(props.typeArguments),
+    // $FlowFixMe[incompatible-call],
+    arguments: props.arguments.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function CatchClause({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function CatchClause(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'CatchClause',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    param: (0, _detachedNode.asDetachedNode)(props.param),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ChainExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ChainExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ChainExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expression: (0, _detachedNode.asDetachedNode)(props.expression)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassBody({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ClassBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ClassBody',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    body: props.body.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ClassDeclaration',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function ClassExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ClassExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ClassExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    superClass: (0, _detachedNode.asDetachedNode)(props.superClass),
+    // $FlowFixMe[incompatible-call],
+    superTypeParameters: (0, _detachedNode.asDetachedNode)(props.superTypeParameters),
+    // $FlowFixMe[incompatible-call],
+    implements: props.implements.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    decorators: props.decorators.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ClassImplements({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ClassImplements(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ClassImplements',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ConditionalExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ConditionalExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ConditionalExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test),
+    // $FlowFixMe[incompatible-call],
+    alternate: (0, _detachedNode.asDetachedNode)(props.alternate),
+    // $FlowFixMe[incompatible-call],
+    consequent: (0, _detachedNode.asDetachedNode)(props.consequent)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ContinueStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ContinueStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ContinueStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    label: (0, _detachedNode.asDetachedNode)(props.label)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DebuggerStatement({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function DebuggerStatement(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DebuggerStatement'
   });
 }
 
-function DeclareClass({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareClass(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareClass',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    extends: props.extends.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    implements: props.implements.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    mixins: props.mixins.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclaredPredicate({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclaredPredicate(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclaredPredicate',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareExportAllDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareExportAllDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareExportAllDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    source: (0, _detachedNode.asDetachedNode)(props.source)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareExportDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'DeclareExportDeclaration',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function DeclareFunction({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'DeclareFunction',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function DeclareInterface({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareInterface(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareInterface',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    extends: props.extends.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareModule({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareModule(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareModule',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    kind: props.kind
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareModuleExports({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareModuleExports(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareModuleExports',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareOpaqueType({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareOpaqueType(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareOpaqueType',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    impltype: (0, _detachedNode.asDetachedNode)(props.impltype),
+    // $FlowFixMe[incompatible-call],
+    supertype: (0, _detachedNode.asDetachedNode)(props.supertype)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareTypeAlias({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareTypeAlias(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareTypeAlias',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DeclareVariable({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DeclareVariable(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DeclareVariable',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function DoWhileStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function DoWhileStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'DoWhileStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EmptyStatement({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function EmptyStatement(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EmptyStatement'
   });
 }
 
-function EmptyTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function EmptyTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EmptyTypeAnnotation'
   });
 }
 
-function EnumBooleanBody({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumBooleanBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumBooleanBody',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumBooleanMember({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumBooleanMember(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumBooleanMember',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: (0, _detachedNode.asDetachedNode)(props.init)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumDefaultedMember({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumDefaultedMember(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumDefaultedMember',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumNumberBody({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumNumberBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumNumberBody',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumNumberMember({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumNumberMember(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumNumberMember',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: (0, _detachedNode.asDetachedNode)(props.init)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumStringBody({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumStringBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumStringBody',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    explicitType: props.explicitType,
+    hasUnknownMembers: props.hasUnknownMembers
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumStringMember({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumStringMember(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumStringMember',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    init: (0, _detachedNode.asDetachedNode)(props.init)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function EnumSymbolBody({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function EnumSymbolBody(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'EnumSymbolBody',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    members: props.members.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    hasUnknownMembers: props.hasUnknownMembers
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ExistsTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function ExistsTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ExistsTypeAnnotation'
   });
 }
 
-function ExportAllDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ExportAllDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ExportAllDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    exported: (0, _detachedNode.asDetachedNode)(props.exported),
+    // $FlowFixMe[incompatible-call],
+    source: (0, _detachedNode.asDetachedNode)(props.source),
+    exportKind: props.exportKind
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ExportDefaultDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ExportDefaultDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ExportDefaultDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    declaration: (0, _detachedNode.asDetachedNode)(props.declaration)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ExportNamedDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ExportNamedDeclaration',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function ExportSpecifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ExportSpecifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ExportSpecifier',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    exported: (0, _detachedNode.asDetachedNode)(props.exported),
+    // $FlowFixMe[incompatible-call],
+    local: (0, _detachedNode.asDetachedNode)(props.local)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ExpressionStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ExpressionStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ExpressionStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expression: (0, _detachedNode.asDetachedNode)(props.expression),
+    directive: props.directive
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ForInStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ForInStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ForInStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ForOfStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ForOfStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ForOfStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    await: props.await
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ForStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ForStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ForStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    init: (0, _detachedNode.asDetachedNode)(props.init),
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test),
+    // $FlowFixMe[incompatible-call],
+    update: (0, _detachedNode.asDetachedNode)(props.update),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function FunctionDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function FunctionDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'FunctionDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    // $FlowFixMe[incompatible-call],
+    predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
+    generator: props.generator,
+    async: props.async
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function FunctionExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function FunctionExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'FunctionExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    // $FlowFixMe[incompatible-call],
+    predicate: (0, _detachedNode.asDetachedNode)(props.predicate),
+    generator: props.generator,
+    async: props.async
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function FunctionTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function FunctionTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'FunctionTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    this: (0, _detachedNode.asDetachedNode)(props.this),
+    // $FlowFixMe[incompatible-call],
+    returnType: (0, _detachedNode.asDetachedNode)(props.returnType),
+    // $FlowFixMe[incompatible-call],
+    rest: (0, _detachedNode.asDetachedNode)(props.rest),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function FunctionTypeParam({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function FunctionTypeParam(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'FunctionTypeParam',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    name: (0, _detachedNode.asDetachedNode)(props.name),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation),
+    optional: props.optional
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function GenericTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function GenericTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'GenericTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function IfStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function IfStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'IfStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test),
+    // $FlowFixMe[incompatible-call],
+    consequent: (0, _detachedNode.asDetachedNode)(props.consequent),
+    // $FlowFixMe[incompatible-call],
+    alternate: (0, _detachedNode.asDetachedNode)(props.alternate)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportAttribute({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportAttribute(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportAttribute',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportDeclaration(props) {
+  var _props$assertions;
+
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    specifiers: props.specifiers.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    source: (0, _detachedNode.asDetachedNode)(props.source),
+    // $FlowFixMe[incompatible-call],
+    assertions: (_props$assertions = props.assertions) == null ? void 0 : _props$assertions.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    importKind: props.importKind
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportDefaultSpecifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportDefaultSpecifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportDefaultSpecifier',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    local: (0, _detachedNode.asDetachedNode)(props.local)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    source: (0, _detachedNode.asDetachedNode)(props.source),
+    // $FlowFixMe[incompatible-call],
+    attributes: (0, _detachedNode.asDetachedNode)(props.attributes)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportNamespaceSpecifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportNamespaceSpecifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportNamespaceSpecifier',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    local: (0, _detachedNode.asDetachedNode)(props.local)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ImportSpecifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ImportSpecifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ImportSpecifier',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    imported: (0, _detachedNode.asDetachedNode)(props.imported),
+    // $FlowFixMe[incompatible-call],
+    local: (0, _detachedNode.asDetachedNode)(props.local),
+    importKind: props.importKind
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function IndexedAccessType({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function IndexedAccessType(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'IndexedAccessType',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    objectType: (0, _detachedNode.asDetachedNode)(props.objectType),
+    // $FlowFixMe[incompatible-call],
+    indexType: (0, _detachedNode.asDetachedNode)(props.indexType)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function InferredPredicate({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function InferredPredicate(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'InferredPredicate'
   });
 }
 
-function InterfaceDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function InterfaceDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'InterfaceDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    extends: props.extends.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function InterfaceExtends({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function InterfaceExtends(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'InterfaceExtends',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function InterfaceTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function InterfaceTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'InterfaceTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    extends: props.extends.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function IntersectionTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function IntersectionTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'IntersectionTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXAttribute({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXAttribute(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXAttribute',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    name: (0, _detachedNode.asDetachedNode)(props.name),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXClosingElement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXClosingElement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXClosingElement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    name: (0, _detachedNode.asDetachedNode)(props.name)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXClosingFragment({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function JSXClosingFragment(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXClosingFragment'
   });
 }
 
-function JSXElement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXElement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXElement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    openingElement: (0, _detachedNode.asDetachedNode)(props.openingElement),
+    // $FlowFixMe[incompatible-call],
+    children: props.children.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    closingElement: (0, _detachedNode.asDetachedNode)(props.closingElement)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXEmptyExpression({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function JSXEmptyExpression(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXEmptyExpression'
   });
 }
 
-function JSXExpressionContainer({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXExpressionContainer(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXExpressionContainer',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expression: (0, _detachedNode.asDetachedNode)(props.expression)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXFragment({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXFragment(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXFragment',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    openingFragment: (0, _detachedNode.asDetachedNode)(props.openingFragment),
+    // $FlowFixMe[incompatible-call],
+    children: props.children.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    closingFragment: (0, _detachedNode.asDetachedNode)(props.closingFragment)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXIdentifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXIdentifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXIdentifier',
-    ...props
+    name: props.name
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXMemberExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXMemberExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXMemberExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    object: (0, _detachedNode.asDetachedNode)(props.object),
+    // $FlowFixMe[incompatible-call],
+    property: (0, _detachedNode.asDetachedNode)(props.property)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXNamespacedName({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXNamespacedName(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXNamespacedName',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    namespace: (0, _detachedNode.asDetachedNode)(props.namespace),
+    // $FlowFixMe[incompatible-call],
+    name: (0, _detachedNode.asDetachedNode)(props.name)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXOpeningElement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXOpeningElement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXOpeningElement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    name: (0, _detachedNode.asDetachedNode)(props.name),
+    // $FlowFixMe[incompatible-call],
+    attributes: props.attributes.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    selfClosing: props.selfClosing
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXOpeningFragment({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function JSXOpeningFragment(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXOpeningFragment'
   });
 }
 
-function JSXSpreadAttribute({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXSpreadAttribute(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXSpreadAttribute',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXSpreadChild({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXSpreadChild(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXSpreadChild',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expression: (0, _detachedNode.asDetachedNode)(props.expression)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function JSXText({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function JSXText(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'JSXText',
-    ...props
+    value: props.value,
+    raw: props.raw
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function LabeledStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function LabeledStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'LabeledStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    label: (0, _detachedNode.asDetachedNode)(props.label),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function LogicalExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function LogicalExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'LogicalExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    left: (0, _detachedNode.asDetachedNode)(props.left),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right),
+    operator: props.operator
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function MemberExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function MemberExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MemberExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    object: (0, _detachedNode.asDetachedNode)(props.object),
+    // $FlowFixMe[incompatible-call],
+    property: (0, _detachedNode.asDetachedNode)(props.property),
+    computed: props.computed
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function MetaProperty({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function MetaProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MetaProperty',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    meta: (0, _detachedNode.asDetachedNode)(props.meta),
+    // $FlowFixMe[incompatible-call],
+    property: (0, _detachedNode.asDetachedNode)(props.property)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function MethodDefinition({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function MethodDefinition(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MethodDefinition',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    kind: props.kind,
+    computed: props.computed,
+    static: props.static
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function MixedTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function MixedTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MixedTypeAnnotation'
   });
 }
 
-function NewExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function NewExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NewExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    callee: (0, _detachedNode.asDetachedNode)(props.callee),
+    // $FlowFixMe[incompatible-call],
+    typeArguments: (0, _detachedNode.asDetachedNode)(props.typeArguments),
+    // $FlowFixMe[incompatible-call],
+    arguments: props.arguments.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function NullableTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function NullableTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NullableTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function NullLiteralTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function NullLiteralTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NullLiteralTypeAnnotation'
   });
 }
 
-function NumberLiteralTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function NumberLiteralTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NumberLiteralTypeAnnotation',
-    ...props
+    value: props.value,
+    raw: props.raw
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function NumberTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function NumberTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'NumberTypeAnnotation'
   });
 }
 
-function ObjectExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectPattern({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectPattern',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    indexers: props.indexers.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    callProperties: props.callProperties.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    internalSlots: props.internalSlots.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    inexact: props.inexact,
+    exact: props.exact
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectTypeCallProperty({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectTypeCallProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectTypeCallProperty',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    static: props.static
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectTypeIndexer({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectTypeIndexer(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectTypeIndexer',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    static: props.static,
+    // $FlowFixMe[incompatible-call],
+    variance: (0, _detachedNode.asDetachedNode)(props.variance)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectTypeInternalSlot({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectTypeInternalSlot(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectTypeInternalSlot',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    optional: props.optional,
+    static: props.static,
+    method: props.method
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ObjectTypeProperty({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
-    type: 'ObjectTypeProperty',
-    ...props
-  });
-  (0, _detachedNode.setParentPointersInDirectChildren)(node);
-  return node;
-}
-
-function ObjectTypeSpreadProperty({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ObjectTypeSpreadProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ObjectTypeSpreadProperty',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function OpaqueType({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function OpaqueType(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'OpaqueType',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    impltype: (0, _detachedNode.asDetachedNode)(props.impltype),
+    // $FlowFixMe[incompatible-call],
+    supertype: (0, _detachedNode.asDetachedNode)(props.supertype)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function OptionalIndexedAccessType({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function OptionalIndexedAccessType(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'OptionalIndexedAccessType',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    objectType: (0, _detachedNode.asDetachedNode)(props.objectType),
+    // $FlowFixMe[incompatible-call],
+    indexType: (0, _detachedNode.asDetachedNode)(props.indexType),
+    optional: props.optional
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function PrivateIdentifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function PrivateIdentifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'PrivateIdentifier',
-    ...props
+    name: props.name
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function Property({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function Property(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Property',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    kind: props.kind,
+    computed: props.computed,
+    method: props.method,
+    shorthand: props.shorthand
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function PropertyDefinition({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function PropertyDefinition(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'PropertyDefinition',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    key: (0, _detachedNode.asDetachedNode)(props.key),
+    // $FlowFixMe[incompatible-call],
+    value: (0, _detachedNode.asDetachedNode)(props.value),
+    computed: props.computed,
+    static: props.static,
+    declare: props.declare,
+    optional: props.optional,
+    // $FlowFixMe[incompatible-call],
+    variance: (0, _detachedNode.asDetachedNode)(props.variance),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation),
+    // $FlowFixMe[incompatible-call],
+    tsModifiers: (0, _detachedNode.asDetachedNode)(props.tsModifiers)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function QualifiedTypeIdentifier({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function QualifiedTypeIdentifier(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'QualifiedTypeIdentifier',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    qualification: (0, _detachedNode.asDetachedNode)(props.qualification),
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function RestElement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function RestElement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'RestElement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ReturnStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ReturnStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ReturnStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function SequenceExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function SequenceExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'SequenceExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expressions: props.expressions.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function SpreadElement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function SpreadElement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'SpreadElement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function StringLiteralTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function StringLiteralTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'StringLiteralTypeAnnotation',
-    ...props
+    value: props.value,
+    raw: props.raw
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function StringTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function StringTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'StringTypeAnnotation'
   });
 }
 
-function Super({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function Super(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Super'
   });
 }
 
-function SwitchCase({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function SwitchCase(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'SwitchCase',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test),
+    // $FlowFixMe[incompatible-call],
+    consequent: props.consequent.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function SwitchStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function SwitchStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'SwitchStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    discriminant: (0, _detachedNode.asDetachedNode)(props.discriminant),
+    // $FlowFixMe[incompatible-call],
+    cases: props.cases.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function SymbolTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function SymbolTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'SymbolTypeAnnotation'
   });
 }
 
-function TaggedTemplateExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TaggedTemplateExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TaggedTemplateExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    tag: (0, _detachedNode.asDetachedNode)(props.tag),
+    // $FlowFixMe[incompatible-call],
+    quasi: (0, _detachedNode.asDetachedNode)(props.quasi)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TemplateLiteral({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TemplateLiteral(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TemplateLiteral',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    quasis: props.quasis.map(n => (0, _detachedNode.asDetachedNode)(n)),
+    // $FlowFixMe[incompatible-call],
+    expressions: props.expressions.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function ThisExpression({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function ThisExpression(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ThisExpression'
   });
 }
 
-function ThisTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function ThisTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ThisTypeAnnotation'
   });
 }
 
-function ThrowStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function ThrowStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'ThrowStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TryStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TryStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TryStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    block: (0, _detachedNode.asDetachedNode)(props.block),
+    // $FlowFixMe[incompatible-call],
+    handler: (0, _detachedNode.asDetachedNode)(props.handler),
+    // $FlowFixMe[incompatible-call],
+    finalizer: (0, _detachedNode.asDetachedNode)(props.finalizer)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TupleTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TupleTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TupleTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeAlias({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeAlias(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeAlias',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id),
+    // $FlowFixMe[incompatible-call],
+    typeParameters: (0, _detachedNode.asDetachedNode)(props.typeParameters),
+    // $FlowFixMe[incompatible-call],
+    right: (0, _detachedNode.asDetachedNode)(props.right)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeCastExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeCastExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeCastExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    expression: (0, _detachedNode.asDetachedNode)(props.expression),
+    // $FlowFixMe[incompatible-call],
+    typeAnnotation: (0, _detachedNode.asDetachedNode)(props.typeAnnotation)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeofTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeofTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeofTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeParameter({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeParameter(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeParameter',
-    ...props
+    name: props.name,
+    // $FlowFixMe[incompatible-call],
+    bound: (0, _detachedNode.asDetachedNode)(props.bound),
+    // $FlowFixMe[incompatible-call],
+    variance: (0, _detachedNode.asDetachedNode)(props.variance),
+    // $FlowFixMe[incompatible-call],
+    default: (0, _detachedNode.asDetachedNode)(props.default)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeParameterDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeParameterDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeParameterDeclaration',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function TypeParameterInstantiation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function TypeParameterInstantiation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeParameterInstantiation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    params: props.params.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function UnaryExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function UnaryExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'UnaryExpression',
-    ...props
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument),
+    prefix: props.prefix
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function UnionTypeAnnotation({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function UnionTypeAnnotation(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'UnionTypeAnnotation',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    types: props.types.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function UpdateExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function UpdateExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'UpdateExpression',
-    ...props
+    operator: props.operator,
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument),
+    prefix: props.prefix
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function VariableDeclaration({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function VariableDeclaration(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'VariableDeclaration',
-    ...props
+    kind: props.kind,
+    // $FlowFixMe[incompatible-call],
+    declarations: props.declarations.map(n => (0, _detachedNode.asDetachedNode)(n))
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function VariableDeclarator({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function VariableDeclarator(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'VariableDeclarator',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    init: (0, _detachedNode.asDetachedNode)(props.init),
+    // $FlowFixMe[incompatible-call],
+    id: (0, _detachedNode.asDetachedNode)(props.id)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function Variance({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function Variance(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'Variance',
-    ...props
+    kind: props.kind
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function VoidTypeAnnotation({
-  parent
-} = {}) {
-  return (0, _detachedNode.detachedProps)(parent, {
+function VoidTypeAnnotation(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
     type: 'VoidTypeAnnotation'
   });
 }
 
-function WhileStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function WhileStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'WhileStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body),
+    // $FlowFixMe[incompatible-call],
+    test: (0, _detachedNode.asDetachedNode)(props.test)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function WithStatement({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function WithStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'WithStatement',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    object: (0, _detachedNode.asDetachedNode)(props.object),
+    // $FlowFixMe[incompatible-call],
+    body: (0, _detachedNode.asDetachedNode)(props.body)
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;
 }
 
-function YieldExpression({
-  parent,
-  ...props
-}) {
-  const node = (0, _detachedNode.detachedProps)(parent, {
+function YieldExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'YieldExpression',
-    ...props
+    // $FlowFixMe[incompatible-call],
+    argument: (0, _detachedNode.asDetachedNode)(props.argument),
+    delegate: props.delegate
   });
   (0, _detachedNode.setParentPointersInDirectChildren)(node);
   return node;