hermes-transform 0.5.0

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

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