hermes-estree 0.10.0 → 0.11.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -17,7 +17,7 @@
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 
 'use strict';
 
@@ -45,11 +45,18 @@ import type {
   ClassDeclaration,
   ClassExpression,
   ClassImplements,
+  ComponentDeclaration,
+  ComponentParameter,
+  ComponentTypeAnnotation,
+  ComponentTypeParameter,
   ConditionalExpression,
+  ConditionalTypeAnnotation,
   ContinueStatement,
   DebuggerStatement,
   DeclareClass,
+  DeclareComponent,
   DeclaredPredicate,
+  DeclareEnum,
   DeclareExportAllDeclaration,
   DeclareExportDeclaration,
   DeclareFunction,
@@ -95,6 +102,7 @@ import type {
   ImportSpecifier,
   IndexedAccessType,
   InferredPredicate,
+  InferTypeAnnotation,
   InterfaceDeclaration,
   InterfaceExtends,
   InterfaceTypeAnnotation,
@@ -114,6 +122,7 @@ import type {
   JSXSpreadAttribute,
   JSXSpreadChild,
   JSXText,
+  KeyofTypeAnnotation,
   LabeledStatement,
   LogicalExpression,
   MemberExpression,
@@ -131,6 +140,7 @@ import type {
   ObjectTypeCallProperty,
   ObjectTypeIndexer,
   ObjectTypeInternalSlot,
+  ObjectTypeMappedTypeProperty,
   ObjectTypeProperty,
   ObjectTypeSpreadProperty,
   OpaqueType,
@@ -140,6 +150,7 @@ import type {
   Property,
   PropertyDefinition,
   QualifiedTypeIdentifier,
+  QualifiedTypeofIdentifier,
   RestElement,
   ReturnStatement,
   SequenceExpression,
@@ -158,6 +169,8 @@ import type {
   ThrowStatement,
   TryStatement,
   TupleTypeAnnotation,
+  TupleTypeLabeledElement,
+  TupleTypeSpreadElement,
   TypeAlias,
   TypeAnnotation,
   TypeCastExpression,
@@ -165,6 +178,7 @@ import type {
   TypeParameter,
   TypeParameterDeclaration,
   TypeParameterInstantiation,
+  TypePredicate,
   UnaryExpression,
   UnionTypeAnnotation,
   UpdateExpression,
@@ -335,6 +349,55 @@ interface ClassImplements_With_id extends ClassImplements {
 interface ClassImplements_With_typeParameters extends ClassImplements {
   +typeParameters: $NonMaybeType<ClassImplements['typeParameters']>;
 }
+interface ComponentDeclaration_With_id extends ComponentDeclaration {
+  +id: $NonMaybeType<ComponentDeclaration['id']>;
+}
+interface ComponentDeclaration_With_params extends ComponentDeclaration {
+  +params: $NonMaybeType<ComponentDeclaration['params']>;
+}
+interface ComponentDeclaration_With_body extends ComponentDeclaration {
+  +body: $NonMaybeType<ComponentDeclaration['body']>;
+}
+interface ComponentDeclaration_With_typeParameters
+  extends ComponentDeclaration {
+  +typeParameters: $NonMaybeType<ComponentDeclaration['typeParameters']>;
+}
+interface ComponentDeclaration_With_returnType extends ComponentDeclaration {
+  +returnType: $NonMaybeType<ComponentDeclaration['returnType']>;
+}
+interface ComponentParameter_With_name extends ComponentParameter {
+  +name: $NonMaybeType<ComponentParameter['name']>;
+}
+interface ComponentParameter_With_local extends ComponentParameter {
+  +local: $NonMaybeType<ComponentParameter['local']>;
+}
+interface ComponentParameter_With_shorthand extends ComponentParameter {
+  +shorthand: $NonMaybeType<ComponentParameter['shorthand']>;
+}
+interface ComponentTypeAnnotation_With_params extends ComponentTypeAnnotation {
+  +params: $NonMaybeType<ComponentTypeAnnotation['params']>;
+}
+interface ComponentTypeAnnotation_With_rest extends ComponentTypeAnnotation {
+  +rest: $NonMaybeType<ComponentTypeAnnotation['rest']>;
+}
+interface ComponentTypeAnnotation_With_typeParameters
+  extends ComponentTypeAnnotation {
+  +typeParameters: $NonMaybeType<ComponentTypeAnnotation['typeParameters']>;
+}
+interface ComponentTypeAnnotation_With_returnType
+  extends ComponentTypeAnnotation {
+  +returnType: $NonMaybeType<ComponentTypeAnnotation['returnType']>;
+}
+interface ComponentTypeParameter_With_name extends ComponentTypeParameter {
+  +name: $NonMaybeType<ComponentTypeParameter['name']>;
+}
+interface ComponentTypeParameter_With_typeAnnotation
+  extends ComponentTypeParameter {
+  +typeAnnotation: $NonMaybeType<ComponentTypeParameter['typeAnnotation']>;
+}
+interface ComponentTypeParameter_With_optional extends ComponentTypeParameter {
+  +optional: $NonMaybeType<ComponentTypeParameter['optional']>;
+}
 interface ConditionalExpression_With_test extends ConditionalExpression {
   +test: $NonMaybeType<ConditionalExpression['test']>;
 }
@@ -344,6 +407,22 @@ interface ConditionalExpression_With_alternate extends ConditionalExpression {
 interface ConditionalExpression_With_consequent extends ConditionalExpression {
   +consequent: $NonMaybeType<ConditionalExpression['consequent']>;
 }
+interface ConditionalTypeAnnotation_With_checkType
+  extends ConditionalTypeAnnotation {
+  +checkType: $NonMaybeType<ConditionalTypeAnnotation['checkType']>;
+}
+interface ConditionalTypeAnnotation_With_extendsType
+  extends ConditionalTypeAnnotation {
+  +extendsType: $NonMaybeType<ConditionalTypeAnnotation['extendsType']>;
+}
+interface ConditionalTypeAnnotation_With_trueType
+  extends ConditionalTypeAnnotation {
+  +trueType: $NonMaybeType<ConditionalTypeAnnotation['trueType']>;
+}
+interface ConditionalTypeAnnotation_With_falseType
+  extends ConditionalTypeAnnotation {
+  +falseType: $NonMaybeType<ConditionalTypeAnnotation['falseType']>;
+}
 interface ContinueStatement_With_label extends ContinueStatement {
   +label: $NonMaybeType<ContinueStatement['label']>;
 }
@@ -365,9 +444,30 @@ interface DeclareClass_With_mixins extends DeclareClass {
 interface DeclareClass_With_body extends DeclareClass {
   +body: $NonMaybeType<DeclareClass['body']>;
 }
+interface DeclareComponent_With_id extends DeclareComponent {
+  +id: $NonMaybeType<DeclareComponent['id']>;
+}
+interface DeclareComponent_With_params extends DeclareComponent {
+  +params: $NonMaybeType<DeclareComponent['params']>;
+}
+interface DeclareComponent_With_rest extends DeclareComponent {
+  +rest: $NonMaybeType<DeclareComponent['rest']>;
+}
+interface DeclareComponent_With_typeParameters extends DeclareComponent {
+  +typeParameters: $NonMaybeType<DeclareComponent['typeParameters']>;
+}
+interface DeclareComponent_With_returnType extends DeclareComponent {
+  +returnType: $NonMaybeType<DeclareComponent['returnType']>;
+}
 interface DeclaredPredicate_With_value extends DeclaredPredicate {
   +value: $NonMaybeType<DeclaredPredicate['value']>;
 }
+interface DeclareEnum_With_id extends DeclareEnum {
+  +id: $NonMaybeType<DeclareEnum['id']>;
+}
+interface DeclareEnum_With_body extends DeclareEnum {
+  +body: $NonMaybeType<DeclareEnum['body']>;
+}
 interface DeclareExportAllDeclaration_With_source
   extends DeclareExportAllDeclaration {
   +source: $NonMaybeType<DeclareExportAllDeclaration['source']>;
@@ -443,6 +543,9 @@ interface DeclareTypeAlias_With_right extends DeclareTypeAlias {
 interface DeclareVariable_With_id extends DeclareVariable {
   +id: $NonMaybeType<DeclareVariable['id']>;
 }
+interface DeclareVariable_With_kind extends DeclareVariable {
+  +kind: $NonMaybeType<DeclareVariable['kind']>;
+}
 interface DoWhileStatement_With_body extends DoWhileStatement {
   +body: $NonMaybeType<DoWhileStatement['body']>;
 }
@@ -726,6 +829,9 @@ interface IndexedAccessType_With_objectType extends IndexedAccessType {
 interface IndexedAccessType_With_indexType extends IndexedAccessType {
   +indexType: $NonMaybeType<IndexedAccessType['indexType']>;
 }
+interface InferTypeAnnotation_With_typeParameter extends InferTypeAnnotation {
+  +typeParameter: $NonMaybeType<InferTypeAnnotation['typeParameter']>;
+}
 interface InterfaceDeclaration_With_id extends InterfaceDeclaration {
   +id: $NonMaybeType<InterfaceDeclaration['id']>;
 }
@@ -810,6 +916,9 @@ interface JSXOpeningElement_With_attributes extends JSXOpeningElement {
 interface JSXOpeningElement_With_selfClosing extends JSXOpeningElement {
   +selfClosing: $NonMaybeType<JSXOpeningElement['selfClosing']>;
 }
+interface JSXOpeningElement_With_typeArguments extends JSXOpeningElement {
+  +typeArguments: $NonMaybeType<JSXOpeningElement['typeArguments']>;
+}
 interface JSXSpreadAttribute_With_argument extends JSXSpreadAttribute {
   +argument: $NonMaybeType<JSXSpreadAttribute['argument']>;
 }
@@ -822,6 +931,9 @@ interface JSXText_With_value extends JSXText {
 interface JSXText_With_raw extends JSXText {
   +raw: $NonMaybeType<JSXText['raw']>;
 }
+interface KeyofTypeAnnotation_With_argument extends KeyofTypeAnnotation {
+  +argument: $NonMaybeType<KeyofTypeAnnotation['argument']>;
+}
 interface LabeledStatement_With_label extends LabeledStatement {
   +label: $NonMaybeType<LabeledStatement['label']>;
 }
@@ -952,6 +1064,26 @@ interface ObjectTypeInternalSlot_With_static extends ObjectTypeInternalSlot {
 interface ObjectTypeInternalSlot_With_method extends ObjectTypeInternalSlot {
   +method: $NonMaybeType<ObjectTypeInternalSlot['method']>;
 }
+interface ObjectTypeMappedTypeProperty_With_keyTparam
+  extends ObjectTypeMappedTypeProperty {
+  +keyTparam: $NonMaybeType<ObjectTypeMappedTypeProperty['keyTparam']>;
+}
+interface ObjectTypeMappedTypeProperty_With_propType
+  extends ObjectTypeMappedTypeProperty {
+  +propType: $NonMaybeType<ObjectTypeMappedTypeProperty['propType']>;
+}
+interface ObjectTypeMappedTypeProperty_With_sourceType
+  extends ObjectTypeMappedTypeProperty {
+  +sourceType: $NonMaybeType<ObjectTypeMappedTypeProperty['sourceType']>;
+}
+interface ObjectTypeMappedTypeProperty_With_variance
+  extends ObjectTypeMappedTypeProperty {
+  +variance: $NonMaybeType<ObjectTypeMappedTypeProperty['variance']>;
+}
+interface ObjectTypeMappedTypeProperty_With_optional
+  extends ObjectTypeMappedTypeProperty {
+  +optional: $NonMaybeType<ObjectTypeMappedTypeProperty['optional']>;
+}
 interface ObjectTypeProperty_With_key extends ObjectTypeProperty {
   +key: $NonMaybeType<ObjectTypeProperty['key']>;
 }
@@ -1062,6 +1194,13 @@ interface QualifiedTypeIdentifier_With_qualification
 interface QualifiedTypeIdentifier_With_id extends QualifiedTypeIdentifier {
   +id: $NonMaybeType<QualifiedTypeIdentifier['id']>;
 }
+interface QualifiedTypeofIdentifier_With_qualification
+  extends QualifiedTypeofIdentifier {
+  +qualification: $NonMaybeType<QualifiedTypeofIdentifier['qualification']>;
+}
+interface QualifiedTypeofIdentifier_With_id extends QualifiedTypeofIdentifier {
+  +id: $NonMaybeType<QualifiedTypeofIdentifier['id']>;
+}
 interface RestElement_With_argument extends RestElement {
   +argument: $NonMaybeType<RestElement['argument']>;
 }
@@ -1130,6 +1269,28 @@ interface TryStatement_With_finalizer extends TryStatement {
 interface TupleTypeAnnotation_With_types extends TupleTypeAnnotation {
   +types: $NonMaybeType<TupleTypeAnnotation['types']>;
 }
+interface TupleTypeLabeledElement_With_label extends TupleTypeLabeledElement {
+  +label: $NonMaybeType<TupleTypeLabeledElement['label']>;
+}
+interface TupleTypeLabeledElement_With_elementType
+  extends TupleTypeLabeledElement {
+  +elementType: $NonMaybeType<TupleTypeLabeledElement['elementType']>;
+}
+interface TupleTypeLabeledElement_With_optional
+  extends TupleTypeLabeledElement {
+  +optional: $NonMaybeType<TupleTypeLabeledElement['optional']>;
+}
+interface TupleTypeLabeledElement_With_variance
+  extends TupleTypeLabeledElement {
+  +variance: $NonMaybeType<TupleTypeLabeledElement['variance']>;
+}
+interface TupleTypeSpreadElement_With_label extends TupleTypeSpreadElement {
+  +label: $NonMaybeType<TupleTypeSpreadElement['label']>;
+}
+interface TupleTypeSpreadElement_With_typeAnnotation
+  extends TupleTypeSpreadElement {
+  +typeAnnotation: $NonMaybeType<TupleTypeSpreadElement['typeAnnotation']>;
+}
 interface TypeAlias_With_id extends TypeAlias {
   +id: $NonMaybeType<TypeAlias['id']>;
 }
@@ -1171,6 +1332,15 @@ interface TypeParameterInstantiation_With_params
   extends TypeParameterInstantiation {
   +params: $NonMaybeType<TypeParameterInstantiation['params']>;
 }
+interface TypePredicate_With_parameterName extends TypePredicate {
+  +parameterName: $NonMaybeType<TypePredicate['parameterName']>;
+}
+interface TypePredicate_With_typeAnnotation extends TypePredicate {
+  +typeAnnotation: $NonMaybeType<TypePredicate['typeAnnotation']>;
+}
+interface TypePredicate_With_asserts extends TypePredicate {
+  +asserts: $NonMaybeType<TypePredicate['asserts']>;
+}
 interface UnaryExpression_With_operator extends UnaryExpression {
   +operator: $NonMaybeType<UnaryExpression['operator']>;
 }
@@ -1247,6 +1417,7 @@ type StatementSpecialSelector =
   | WithStatement;
 type DeclarationSpecialSelector =
   | ClassDeclaration
+  | ComponentDeclaration
   | DeclareExportAllDeclaration
   | DeclareExportDeclaration
   | EnumDeclaration
@@ -1427,6 +1598,49 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ClassImplements[typeParameters]'?: (
     node: ClassImplements_With_typeParameters,
   ) => void,
+  +ComponentDeclaration?: (node: ComponentDeclaration) => void,
+  +'ComponentDeclaration[id]'?: (node: ComponentDeclaration_With_id) => void,
+  +'ComponentDeclaration[params]'?: (
+    node: ComponentDeclaration_With_params,
+  ) => void,
+  +'ComponentDeclaration[body]'?: (
+    node: ComponentDeclaration_With_body,
+  ) => void,
+  +'ComponentDeclaration[typeParameters]'?: (
+    node: ComponentDeclaration_With_typeParameters,
+  ) => void,
+  +'ComponentDeclaration[returnType]'?: (
+    node: ComponentDeclaration_With_returnType,
+  ) => void,
+  +ComponentParameter?: (node: ComponentParameter) => void,
+  +'ComponentParameter[name]'?: (node: ComponentParameter_With_name) => void,
+  +'ComponentParameter[local]'?: (node: ComponentParameter_With_local) => void,
+  +'ComponentParameter[shorthand]'?: (
+    node: ComponentParameter_With_shorthand,
+  ) => void,
+  +ComponentTypeAnnotation?: (node: ComponentTypeAnnotation) => void,
+  +'ComponentTypeAnnotation[params]'?: (
+    node: ComponentTypeAnnotation_With_params,
+  ) => void,
+  +'ComponentTypeAnnotation[rest]'?: (
+    node: ComponentTypeAnnotation_With_rest,
+  ) => void,
+  +'ComponentTypeAnnotation[typeParameters]'?: (
+    node: ComponentTypeAnnotation_With_typeParameters,
+  ) => void,
+  +'ComponentTypeAnnotation[returnType]'?: (
+    node: ComponentTypeAnnotation_With_returnType,
+  ) => void,
+  +ComponentTypeParameter?: (node: ComponentTypeParameter) => void,
+  +'ComponentTypeParameter[name]'?: (
+    node: ComponentTypeParameter_With_name,
+  ) => void,
+  +'ComponentTypeParameter[typeAnnotation]'?: (
+    node: ComponentTypeParameter_With_typeAnnotation,
+  ) => void,
+  +'ComponentTypeParameter[optional]'?: (
+    node: ComponentTypeParameter_With_optional,
+  ) => void,
   +ConditionalExpression?: (node: ConditionalExpression) => void,
   +'ConditionalExpression[test]'?: (
     node: ConditionalExpression_With_test,
@@ -1437,6 +1651,19 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ConditionalExpression[consequent]'?: (
     node: ConditionalExpression_With_consequent,
   ) => void,
+  +ConditionalTypeAnnotation?: (node: ConditionalTypeAnnotation) => void,
+  +'ConditionalTypeAnnotation[checkType]'?: (
+    node: ConditionalTypeAnnotation_With_checkType,
+  ) => void,
+  +'ConditionalTypeAnnotation[extendsType]'?: (
+    node: ConditionalTypeAnnotation_With_extendsType,
+  ) => void,
+  +'ConditionalTypeAnnotation[trueType]'?: (
+    node: ConditionalTypeAnnotation_With_trueType,
+  ) => void,
+  +'ConditionalTypeAnnotation[falseType]'?: (
+    node: ConditionalTypeAnnotation_With_falseType,
+  ) => void,
   +ContinueStatement?: (node: ContinueStatement) => void,
   +'ContinueStatement[label]'?: (node: ContinueStatement_With_label) => void,
   +DebuggerStatement?: (node: DebuggerStatement) => void,
@@ -1449,8 +1676,21 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareClass[implements]'?: (node: DeclareClass_With_implements) => void,
   +'DeclareClass[mixins]'?: (node: DeclareClass_With_mixins) => void,
   +'DeclareClass[body]'?: (node: DeclareClass_With_body) => void,
+  +DeclareComponent?: (node: DeclareComponent) => void,
+  +'DeclareComponent[id]'?: (node: DeclareComponent_With_id) => void,
+  +'DeclareComponent[params]'?: (node: DeclareComponent_With_params) => void,
+  +'DeclareComponent[rest]'?: (node: DeclareComponent_With_rest) => void,
+  +'DeclareComponent[typeParameters]'?: (
+    node: DeclareComponent_With_typeParameters,
+  ) => void,
+  +'DeclareComponent[returnType]'?: (
+    node: DeclareComponent_With_returnType,
+  ) => void,
   +DeclaredPredicate?: (node: DeclaredPredicate) => void,
   +'DeclaredPredicate[value]'?: (node: DeclaredPredicate_With_value) => void,
+  +DeclareEnum?: (node: DeclareEnum) => void,
+  +'DeclareEnum[id]'?: (node: DeclareEnum_With_id) => void,
+  +'DeclareEnum[body]'?: (node: DeclareEnum_With_body) => void,
   +DeclareExportAllDeclaration?: (node: DeclareExportAllDeclaration) => void,
   +'DeclareExportAllDeclaration[source]'?: (
     node: DeclareExportAllDeclaration_With_source,
@@ -1507,6 +1747,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareTypeAlias[right]'?: (node: DeclareTypeAlias_With_right) => void,
   +DeclareVariable?: (node: DeclareVariable) => void,
   +'DeclareVariable[id]'?: (node: DeclareVariable_With_id) => void,
+  +'DeclareVariable[kind]'?: (node: DeclareVariable_With_kind) => void,
   +DoWhileStatement?: (node: DoWhileStatement) => void,
   +'DoWhileStatement[body]'?: (node: DoWhileStatement_With_body) => void,
   +'DoWhileStatement[test]'?: (node: DoWhileStatement_With_test) => void,
@@ -1727,6 +1968,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
     node: IndexedAccessType_With_indexType,
   ) => void,
   +InferredPredicate?: (node: InferredPredicate) => void,
+  +InferTypeAnnotation?: (node: InferTypeAnnotation) => void,
+  +'InferTypeAnnotation[typeParameter]'?: (
+    node: InferTypeAnnotation_With_typeParameter,
+  ) => void,
   +InterfaceDeclaration?: (node: InterfaceDeclaration) => void,
   +'InterfaceDeclaration[id]'?: (node: InterfaceDeclaration_With_id) => void,
   +'InterfaceDeclaration[typeParameters]'?: (
@@ -1803,6 +2048,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'JSXOpeningElement[selfClosing]'?: (
     node: JSXOpeningElement_With_selfClosing,
   ) => void,
+  +'JSXOpeningElement[typeArguments]'?: (
+    node: JSXOpeningElement_With_typeArguments,
+  ) => void,
   +JSXOpeningFragment?: (node: JSXOpeningFragment) => void,
   +JSXSpreadAttribute?: (node: JSXSpreadAttribute) => void,
   +'JSXSpreadAttribute[argument]'?: (
@@ -1815,6 +2063,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +JSXText?: (node: JSXText) => void,
   +'JSXText[value]'?: (node: JSXText_With_value) => void,
   +'JSXText[raw]'?: (node: JSXText_With_raw) => void,
+  +KeyofTypeAnnotation?: (node: KeyofTypeAnnotation) => void,
+  +'KeyofTypeAnnotation[argument]'?: (
+    node: KeyofTypeAnnotation_With_argument,
+  ) => void,
   +LabeledStatement?: (node: LabeledStatement) => void,
   +'LabeledStatement[label]'?: (node: LabeledStatement_With_label) => void,
   +'LabeledStatement[body]'?: (node: LabeledStatement_With_body) => void,
@@ -1922,6 +2174,22 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ObjectTypeInternalSlot[method]'?: (
     node: ObjectTypeInternalSlot_With_method,
   ) => void,
+  +ObjectTypeMappedTypeProperty?: (node: ObjectTypeMappedTypeProperty) => void,
+  +'ObjectTypeMappedTypeProperty[keyTparam]'?: (
+    node: ObjectTypeMappedTypeProperty_With_keyTparam,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[propType]'?: (
+    node: ObjectTypeMappedTypeProperty_With_propType,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[sourceType]'?: (
+    node: ObjectTypeMappedTypeProperty_With_sourceType,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[variance]'?: (
+    node: ObjectTypeMappedTypeProperty_With_variance,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[optional]'?: (
+    node: ObjectTypeMappedTypeProperty_With_optional,
+  ) => void,
   +ObjectTypeProperty?: (node: ObjectTypeProperty) => void,
   +'ObjectTypeProperty[key]'?: (node: ObjectTypeProperty_With_key) => void,
   +'ObjectTypeProperty[value]'?: (node: ObjectTypeProperty_With_value) => void,
@@ -2002,6 +2270,13 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'QualifiedTypeIdentifier[id]'?: (
     node: QualifiedTypeIdentifier_With_id,
   ) => void,
+  +QualifiedTypeofIdentifier?: (node: QualifiedTypeofIdentifier) => void,
+  +'QualifiedTypeofIdentifier[qualification]'?: (
+    node: QualifiedTypeofIdentifier_With_qualification,
+  ) => void,
+  +'QualifiedTypeofIdentifier[id]'?: (
+    node: QualifiedTypeofIdentifier_With_id,
+  ) => void,
   +RestElement?: (node: RestElement) => void,
   +'RestElement[argument]'?: (node: RestElement_With_argument) => void,
   +ReturnStatement?: (node: ReturnStatement) => void,
@@ -2058,6 +2333,26 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TupleTypeAnnotation[types]'?: (
     node: TupleTypeAnnotation_With_types,
   ) => void,
+  +TupleTypeLabeledElement?: (node: TupleTypeLabeledElement) => void,
+  +'TupleTypeLabeledElement[label]'?: (
+    node: TupleTypeLabeledElement_With_label,
+  ) => void,
+  +'TupleTypeLabeledElement[elementType]'?: (
+    node: TupleTypeLabeledElement_With_elementType,
+  ) => void,
+  +'TupleTypeLabeledElement[optional]'?: (
+    node: TupleTypeLabeledElement_With_optional,
+  ) => void,
+  +'TupleTypeLabeledElement[variance]'?: (
+    node: TupleTypeLabeledElement_With_variance,
+  ) => void,
+  +TupleTypeSpreadElement?: (node: TupleTypeSpreadElement) => void,
+  +'TupleTypeSpreadElement[label]'?: (
+    node: TupleTypeSpreadElement_With_label,
+  ) => void,
+  +'TupleTypeSpreadElement[typeAnnotation]'?: (
+    node: TupleTypeSpreadElement_With_typeAnnotation,
+  ) => void,
   +TypeAlias?: (node: TypeAlias) => void,
   +'TypeAlias[id]'?: (node: TypeAlias_With_id) => void,
   +'TypeAlias[typeParameters]'?: (node: TypeAlias_With_typeParameters) => void,
@@ -2090,6 +2385,14 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeParameterInstantiation[params]'?: (
     node: TypeParameterInstantiation_With_params,
   ) => void,
+  +TypePredicate?: (node: TypePredicate) => void,
+  +'TypePredicate[parameterName]'?: (
+    node: TypePredicate_With_parameterName,
+  ) => void,
+  +'TypePredicate[typeAnnotation]'?: (
+    node: TypePredicate_With_typeAnnotation,
+  ) => void,
+  +'TypePredicate[asserts]'?: (node: TypePredicate_With_asserts) => void,
   +UnaryExpression?: (node: UnaryExpression) => void,
   +'UnaryExpression[operator]'?: (node: UnaryExpression_With_operator) => void,
   +'UnaryExpression[argument]'?: (node: UnaryExpression_With_argument) => void,
@@ -2279,6 +2582,55 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ClassImplements[typeParameters]:exit'?: (
     node: ClassImplements_With_typeParameters,
   ) => void,
+  +'ComponentDeclaration:exit'?: (node: ComponentDeclaration) => void,
+  +'ComponentDeclaration[id]:exit'?: (
+    node: ComponentDeclaration_With_id,
+  ) => void,
+  +'ComponentDeclaration[params]:exit'?: (
+    node: ComponentDeclaration_With_params,
+  ) => void,
+  +'ComponentDeclaration[body]:exit'?: (
+    node: ComponentDeclaration_With_body,
+  ) => void,
+  +'ComponentDeclaration[typeParameters]:exit'?: (
+    node: ComponentDeclaration_With_typeParameters,
+  ) => void,
+  +'ComponentDeclaration[returnType]:exit'?: (
+    node: ComponentDeclaration_With_returnType,
+  ) => void,
+  +'ComponentParameter:exit'?: (node: ComponentParameter) => void,
+  +'ComponentParameter[name]:exit'?: (
+    node: ComponentParameter_With_name,
+  ) => void,
+  +'ComponentParameter[local]:exit'?: (
+    node: ComponentParameter_With_local,
+  ) => void,
+  +'ComponentParameter[shorthand]:exit'?: (
+    node: ComponentParameter_With_shorthand,
+  ) => void,
+  +'ComponentTypeAnnotation:exit'?: (node: ComponentTypeAnnotation) => void,
+  +'ComponentTypeAnnotation[params]:exit'?: (
+    node: ComponentTypeAnnotation_With_params,
+  ) => void,
+  +'ComponentTypeAnnotation[rest]:exit'?: (
+    node: ComponentTypeAnnotation_With_rest,
+  ) => void,
+  +'ComponentTypeAnnotation[typeParameters]:exit'?: (
+    node: ComponentTypeAnnotation_With_typeParameters,
+  ) => void,
+  +'ComponentTypeAnnotation[returnType]:exit'?: (
+    node: ComponentTypeAnnotation_With_returnType,
+  ) => void,
+  +'ComponentTypeParameter:exit'?: (node: ComponentTypeParameter) => void,
+  +'ComponentTypeParameter[name]:exit'?: (
+    node: ComponentTypeParameter_With_name,
+  ) => void,
+  +'ComponentTypeParameter[typeAnnotation]:exit'?: (
+    node: ComponentTypeParameter_With_typeAnnotation,
+  ) => void,
+  +'ComponentTypeParameter[optional]:exit'?: (
+    node: ComponentTypeParameter_With_optional,
+  ) => void,
   +'ConditionalExpression:exit'?: (node: ConditionalExpression) => void,
   +'ConditionalExpression[test]:exit'?: (
     node: ConditionalExpression_With_test,
@@ -2289,6 +2641,19 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ConditionalExpression[consequent]:exit'?: (
     node: ConditionalExpression_With_consequent,
   ) => void,
+  +'ConditionalTypeAnnotation:exit'?: (node: ConditionalTypeAnnotation) => void,
+  +'ConditionalTypeAnnotation[checkType]:exit'?: (
+    node: ConditionalTypeAnnotation_With_checkType,
+  ) => void,
+  +'ConditionalTypeAnnotation[extendsType]:exit'?: (
+    node: ConditionalTypeAnnotation_With_extendsType,
+  ) => void,
+  +'ConditionalTypeAnnotation[trueType]:exit'?: (
+    node: ConditionalTypeAnnotation_With_trueType,
+  ) => void,
+  +'ConditionalTypeAnnotation[falseType]:exit'?: (
+    node: ConditionalTypeAnnotation_With_falseType,
+  ) => void,
   +'ContinueStatement:exit'?: (node: ContinueStatement) => void,
   +'ContinueStatement[label]:exit'?: (
     node: ContinueStatement_With_label,
@@ -2305,10 +2670,25 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'DeclareClass[mixins]:exit'?: (node: DeclareClass_With_mixins) => void,
   +'DeclareClass[body]:exit'?: (node: DeclareClass_With_body) => void,
+  +'DeclareComponent:exit'?: (node: DeclareComponent) => void,
+  +'DeclareComponent[id]:exit'?: (node: DeclareComponent_With_id) => void,
+  +'DeclareComponent[params]:exit'?: (
+    node: DeclareComponent_With_params,
+  ) => void,
+  +'DeclareComponent[rest]:exit'?: (node: DeclareComponent_With_rest) => void,
+  +'DeclareComponent[typeParameters]:exit'?: (
+    node: DeclareComponent_With_typeParameters,
+  ) => void,
+  +'DeclareComponent[returnType]:exit'?: (
+    node: DeclareComponent_With_returnType,
+  ) => void,
   +'DeclaredPredicate:exit'?: (node: DeclaredPredicate) => void,
   +'DeclaredPredicate[value]:exit'?: (
     node: DeclaredPredicate_With_value,
   ) => void,
+  +'DeclareEnum:exit'?: (node: DeclareEnum) => void,
+  +'DeclareEnum[id]:exit'?: (node: DeclareEnum_With_id) => void,
+  +'DeclareEnum[body]:exit'?: (node: DeclareEnum_With_body) => void,
   +'DeclareExportAllDeclaration:exit'?: (
     node: DeclareExportAllDeclaration,
   ) => void,
@@ -2369,6 +2749,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareTypeAlias[right]:exit'?: (node: DeclareTypeAlias_With_right) => void,
   +'DeclareVariable:exit'?: (node: DeclareVariable) => void,
   +'DeclareVariable[id]:exit'?: (node: DeclareVariable_With_id) => void,
+  +'DeclareVariable[kind]:exit'?: (node: DeclareVariable_With_kind) => void,
   +'DoWhileStatement:exit'?: (node: DoWhileStatement) => void,
   +'DoWhileStatement[body]:exit'?: (node: DoWhileStatement_With_body) => void,
   +'DoWhileStatement[test]:exit'?: (node: DoWhileStatement_With_test) => void,
@@ -2607,6 +2988,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
     node: IndexedAccessType_With_indexType,
   ) => void,
   +'InferredPredicate:exit'?: (node: InferredPredicate) => void,
+  +'InferTypeAnnotation:exit'?: (node: InferTypeAnnotation) => void,
+  +'InferTypeAnnotation[typeParameter]:exit'?: (
+    node: InferTypeAnnotation_With_typeParameter,
+  ) => void,
   +'InterfaceDeclaration:exit'?: (node: InterfaceDeclaration) => void,
   +'InterfaceDeclaration[id]:exit'?: (
     node: InterfaceDeclaration_With_id,
@@ -2687,6 +3072,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'JSXOpeningElement[selfClosing]:exit'?: (
     node: JSXOpeningElement_With_selfClosing,
   ) => void,
+  +'JSXOpeningElement[typeArguments]:exit'?: (
+    node: JSXOpeningElement_With_typeArguments,
+  ) => void,
   +'JSXOpeningFragment:exit'?: (node: JSXOpeningFragment) => void,
   +'JSXSpreadAttribute:exit'?: (node: JSXSpreadAttribute) => void,
   +'JSXSpreadAttribute[argument]:exit'?: (
@@ -2699,6 +3087,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'JSXText:exit'?: (node: JSXText) => void,
   +'JSXText[value]:exit'?: (node: JSXText_With_value) => void,
   +'JSXText[raw]:exit'?: (node: JSXText_With_raw) => void,
+  +'KeyofTypeAnnotation:exit'?: (node: KeyofTypeAnnotation) => void,
+  +'KeyofTypeAnnotation[argument]:exit'?: (
+    node: KeyofTypeAnnotation_With_argument,
+  ) => void,
   +'LabeledStatement:exit'?: (node: LabeledStatement) => void,
   +'LabeledStatement[label]:exit'?: (node: LabeledStatement_With_label) => void,
   +'LabeledStatement[body]:exit'?: (node: LabeledStatement_With_body) => void,
@@ -2822,6 +3214,24 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ObjectTypeInternalSlot[method]:exit'?: (
     node: ObjectTypeInternalSlot_With_method,
   ) => void,
+  +'ObjectTypeMappedTypeProperty:exit'?: (
+    node: ObjectTypeMappedTypeProperty,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[keyTparam]:exit'?: (
+    node: ObjectTypeMappedTypeProperty_With_keyTparam,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[propType]:exit'?: (
+    node: ObjectTypeMappedTypeProperty_With_propType,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[sourceType]:exit'?: (
+    node: ObjectTypeMappedTypeProperty_With_sourceType,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[variance]:exit'?: (
+    node: ObjectTypeMappedTypeProperty_With_variance,
+  ) => void,
+  +'ObjectTypeMappedTypeProperty[optional]:exit'?: (
+    node: ObjectTypeMappedTypeProperty_With_optional,
+  ) => void,
   +'ObjectTypeProperty:exit'?: (node: ObjectTypeProperty) => void,
   +'ObjectTypeProperty[key]:exit'?: (node: ObjectTypeProperty_With_key) => void,
   +'ObjectTypeProperty[value]:exit'?: (
@@ -2910,6 +3320,13 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'QualifiedTypeIdentifier[id]:exit'?: (
     node: QualifiedTypeIdentifier_With_id,
   ) => void,
+  +'QualifiedTypeofIdentifier:exit'?: (node: QualifiedTypeofIdentifier) => void,
+  +'QualifiedTypeofIdentifier[qualification]:exit'?: (
+    node: QualifiedTypeofIdentifier_With_qualification,
+  ) => void,
+  +'QualifiedTypeofIdentifier[id]:exit'?: (
+    node: QualifiedTypeofIdentifier_With_id,
+  ) => void,
   +'RestElement:exit'?: (node: RestElement) => void,
   +'RestElement[argument]:exit'?: (node: RestElement_With_argument) => void,
   +'ReturnStatement:exit'?: (node: ReturnStatement) => void,
@@ -2972,6 +3389,26 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TupleTypeAnnotation[types]:exit'?: (
     node: TupleTypeAnnotation_With_types,
   ) => void,
+  +'TupleTypeLabeledElement:exit'?: (node: TupleTypeLabeledElement) => void,
+  +'TupleTypeLabeledElement[label]:exit'?: (
+    node: TupleTypeLabeledElement_With_label,
+  ) => void,
+  +'TupleTypeLabeledElement[elementType]:exit'?: (
+    node: TupleTypeLabeledElement_With_elementType,
+  ) => void,
+  +'TupleTypeLabeledElement[optional]:exit'?: (
+    node: TupleTypeLabeledElement_With_optional,
+  ) => void,
+  +'TupleTypeLabeledElement[variance]:exit'?: (
+    node: TupleTypeLabeledElement_With_variance,
+  ) => void,
+  +'TupleTypeSpreadElement:exit'?: (node: TupleTypeSpreadElement) => void,
+  +'TupleTypeSpreadElement[label]:exit'?: (
+    node: TupleTypeSpreadElement_With_label,
+  ) => void,
+  +'TupleTypeSpreadElement[typeAnnotation]:exit'?: (
+    node: TupleTypeSpreadElement_With_typeAnnotation,
+  ) => void,
   +'TypeAlias:exit'?: (node: TypeAlias) => void,
   +'TypeAlias[id]:exit'?: (node: TypeAlias_With_id) => void,
   +'TypeAlias[typeParameters]:exit'?: (
@@ -3008,6 +3445,14 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypeParameterInstantiation[params]:exit'?: (
     node: TypeParameterInstantiation_With_params,
   ) => void,
+  +'TypePredicate:exit'?: (node: TypePredicate) => void,
+  +'TypePredicate[parameterName]:exit'?: (
+    node: TypePredicate_With_parameterName,
+  ) => void,
+  +'TypePredicate[typeAnnotation]:exit'?: (
+    node: TypePredicate_With_typeAnnotation,
+  ) => void,
+  +'TypePredicate[asserts]:exit'?: (node: TypePredicate_With_asserts) => void,
   +'UnaryExpression:exit'?: (node: UnaryExpression) => void,
   +'UnaryExpression[operator]:exit'?: (
     node: UnaryExpression_With_operator,

package/dist/generated/predicates.js

@@ -18,7 +18,7 @@
 
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
 
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
@@ -72,13 +72,20 @@ exports.isClosingCurlyBracketToken = isClosingCurlyBracketToken;
 exports.isClosingParenthesisToken = isClosingParenthesisToken;
 exports.isColonToken = isColonToken;
 exports.isCommaToken = isCommaToken;
+exports.isComponentDeclaration = isComponentDeclaration;
+exports.isComponentParameter = isComponentParameter;
+exports.isComponentTypeAnnotation = isComponentTypeAnnotation;
+exports.isComponentTypeParameter = isComponentTypeParameter;
 exports.isConditionalExpression = isConditionalExpression;
+exports.isConditionalTypeAnnotation = isConditionalTypeAnnotation;
 exports.isConstToken = isConstToken;
 exports.isContinueStatement = isContinueStatement;
 exports.isContinueToken = isContinueToken;
 exports.isDebuggerStatement = isDebuggerStatement;
 exports.isDebuggerToken = isDebuggerToken;
 exports.isDeclareClass = isDeclareClass;
+exports.isDeclareComponent = isDeclareComponent;
+exports.isDeclareEnum = isDeclareEnum;
 exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
 exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
 exports.isDeclareFunction = isDeclareFunction;
@@ -152,6 +159,7 @@ exports.isImportToken = isImportToken;
 exports.isInToken = isInToken;
 exports.isIncrementToken = isIncrementToken;
 exports.isIndexedAccessType = isIndexedAccessType;
+exports.isInferTypeAnnotation = isInferTypeAnnotation;
 exports.isInferredPredicate = isInferredPredicate;
 exports.isInstanceOfToken = isInstanceOfToken;
 exports.isInterfaceDeclaration = isInterfaceDeclaration;
@@ -175,6 +183,7 @@ exports.isJSXOpeningFragment = isJSXOpeningFragment;
 exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
 exports.isJSXSpreadChild = isJSXSpreadChild;
 exports.isJSXText = isJSXText;
+exports.isKeyofTypeAnnotation = isKeyofTypeAnnotation;
 exports.isLabeledStatement = isLabeledStatement;
 exports.isLessThanOrEqualToToken = isLessThanOrEqualToToken;
 exports.isLessThanToken = isLessThanToken;
@@ -211,6 +220,7 @@ exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
 exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
 exports.isObjectTypeIndexer = isObjectTypeIndexer;
 exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
+exports.isObjectTypeMappedTypeProperty = isObjectTypeMappedTypeProperty;
 exports.isObjectTypeProperty = isObjectTypeProperty;
 exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
 exports.isOfKeyword = isOfKeyword;
@@ -227,6 +237,7 @@ exports.isPrivateIdentifier = isPrivateIdentifier;
 exports.isProperty = isProperty;
 exports.isPropertyDefinition = isPropertyDefinition;
 exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
+exports.isQualifiedTypeofIdentifier = isQualifiedTypeofIdentifier;
 exports.isQuestionMarkToken = isQuestionMarkToken;
 exports.isRemainderEqualToken = isRemainderEqualToken;
 exports.isRestElement = isRestElement;
@@ -258,6 +269,8 @@ exports.isThrowToken = isThrowToken;
 exports.isTryStatement = isTryStatement;
 exports.isTryToken = isTryToken;
 exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
+exports.isTupleTypeLabeledElement = isTupleTypeLabeledElement;
+exports.isTupleTypeSpreadElement = isTupleTypeSpreadElement;
 exports.isTypeAlias = isTypeAlias;
 exports.isTypeAnnotation = isTypeAnnotation;
 exports.isTypeCastExpression = isTypeCastExpression;
@@ -266,6 +279,7 @@ exports.isTypeOfToken = isTypeOfToken;
 exports.isTypeParameter = isTypeParameter;
 exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
 exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
+exports.isTypePredicate = isTypePredicate;
 exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
 exports.isUnaryExpression = isUnaryExpression;
 exports.isUnaryNegationToken = isUnaryNegationToken;
@@ -373,10 +387,30 @@ function isClassImplements(node) {
   return node.type === 'ClassImplements';
 }
 
+function isComponentDeclaration(node) {
+  return node.type === 'ComponentDeclaration';
+}
+
+function isComponentParameter(node) {
+  return node.type === 'ComponentParameter';
+}
+
+function isComponentTypeAnnotation(node) {
+  return node.type === 'ComponentTypeAnnotation';
+}
+
+function isComponentTypeParameter(node) {
+  return node.type === 'ComponentTypeParameter';
+}
+
 function isConditionalExpression(node) {
   return node.type === 'ConditionalExpression';
 }
 
+function isConditionalTypeAnnotation(node) {
+  return node.type === 'ConditionalTypeAnnotation';
+}
+
 function isContinueStatement(node) {
   return node.type === 'ContinueStatement';
 }
@@ -389,10 +423,18 @@ function isDeclareClass(node) {
   return node.type === 'DeclareClass';
 }
 
+function isDeclareComponent(node) {
+  return node.type === 'DeclareComponent';
+}
+
 function isDeclaredPredicate(node) {
   return node.type === 'DeclaredPredicate';
 }
 
+function isDeclareEnum(node) {
+  return node.type === 'DeclareEnum';
+}
+
 function isDeclareExportAllDeclaration(node) {
   return node.type === 'DeclareExportAllDeclaration';
 }
@@ -573,6 +615,10 @@ function isInferredPredicate(node) {
   return node.type === 'InferredPredicate';
 }
 
+function isInferTypeAnnotation(node) {
+  return node.type === 'InferTypeAnnotation';
+}
+
 function isInterfaceDeclaration(node) {
   return node.type === 'InterfaceDeclaration';
 }
@@ -649,6 +695,10 @@ function isJSXText(node) {
   return node.type === 'JSXText';
 }
 
+function isKeyofTypeAnnotation(node) {
+  return node.type === 'KeyofTypeAnnotation';
+}
+
 function isLabeledStatement(node) {
   return node.type === 'LabeledStatement';
 }
@@ -717,6 +767,10 @@ function isObjectTypeInternalSlot(node) {
   return node.type === 'ObjectTypeInternalSlot';
 }
 
+function isObjectTypeMappedTypeProperty(node) {
+  return node.type === 'ObjectTypeMappedTypeProperty';
+}
+
 function isObjectTypeProperty(node) {
   return node.type === 'ObjectTypeProperty';
 }
@@ -749,6 +803,10 @@ function isQualifiedTypeIdentifier(node) {
   return node.type === 'QualifiedTypeIdentifier';
 }
 
+function isQualifiedTypeofIdentifier(node) {
+  return node.type === 'QualifiedTypeofIdentifier';
+}
+
 function isRestElement(node) {
   return node.type === 'RestElement';
 }
@@ -821,6 +879,14 @@ function isTupleTypeAnnotation(node) {
   return node.type === 'TupleTypeAnnotation';
 }
 
+function isTupleTypeLabeledElement(node) {
+  return node.type === 'TupleTypeLabeledElement';
+}
+
+function isTupleTypeSpreadElement(node) {
+  return node.type === 'TupleTypeSpreadElement';
+}
+
 function isTypeAlias(node) {
   return node.type === 'TypeAlias';
 }
@@ -849,6 +915,10 @@ function isTypeParameterInstantiation(node) {
   return node.type === 'TypeParameterInstantiation';
 }
 
+function isTypePredicate(node) {
+  return node.type === 'TypePredicate';
+}
+
 function isUnaryExpression(node) {
   return node.type === 'UnaryExpression';
 }

package/dist/generated/predicates.js.flow

@@ -17,7 +17,7 @@
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, $Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
 
 'use strict';
 
@@ -117,10 +117,36 @@ export function isClassImplements(node: ESNode | Token): boolean %checks {
   return node.type === 'ClassImplements';
 }
 
+export function isComponentDeclaration(node: ESNode | Token): boolean %checks {
+  return node.type === 'ComponentDeclaration';
+}
+
+export function isComponentParameter(node: ESNode | Token): boolean %checks {
+  return node.type === 'ComponentParameter';
+}
+
+export function isComponentTypeAnnotation(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ComponentTypeAnnotation';
+}
+
+export function isComponentTypeParameter(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ComponentTypeParameter';
+}
+
 export function isConditionalExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'ConditionalExpression';
 }
 
+export function isConditionalTypeAnnotation(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ConditionalTypeAnnotation';
+}
+
 export function isContinueStatement(node: ESNode | Token): boolean %checks {
   return node.type === 'ContinueStatement';
 }
@@ -133,10 +159,18 @@ export function isDeclareClass(node: ESNode | Token): boolean %checks {
   return node.type === 'DeclareClass';
 }
 
+export function isDeclareComponent(node: ESNode | Token): boolean %checks {
+  return node.type === 'DeclareComponent';
+}
+
 export function isDeclaredPredicate(node: ESNode | Token): boolean %checks {
   return node.type === 'DeclaredPredicate';
 }
 
+export function isDeclareEnum(node: ESNode | Token): boolean %checks {
+  return node.type === 'DeclareEnum';
+}
+
 export function isDeclareExportAllDeclaration(
   node: ESNode | Token,
 ): boolean %checks {
@@ -331,6 +365,10 @@ export function isInferredPredicate(node: ESNode | Token): boolean %checks {
   return node.type === 'InferredPredicate';
 }
 
+export function isInferTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'InferTypeAnnotation';
+}
+
 export function isInterfaceDeclaration(node: ESNode | Token): boolean %checks {
   return node.type === 'InterfaceDeclaration';
 }
@@ -413,6 +451,10 @@ export function isJSXText(node: ESNode | Token): boolean %checks {
   return node.type === 'JSXText';
 }
 
+export function isKeyofTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'KeyofTypeAnnotation';
+}
+
 export function isLabeledStatement(node: ESNode | Token): boolean %checks {
   return node.type === 'LabeledStatement';
 }
@@ -491,6 +533,12 @@ export function isObjectTypeInternalSlot(
   return node.type === 'ObjectTypeInternalSlot';
 }
 
+export function isObjectTypeMappedTypeProperty(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ObjectTypeMappedTypeProperty';
+}
+
 export function isObjectTypeProperty(node: ESNode | Token): boolean %checks {
   return node.type === 'ObjectTypeProperty';
 }
@@ -529,6 +577,12 @@ export function isQualifiedTypeIdentifier(
   return node.type === 'QualifiedTypeIdentifier';
 }
 
+export function isQualifiedTypeofIdentifier(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'QualifiedTypeofIdentifier';
+}
+
 export function isRestElement(node: ESNode | Token): boolean %checks {
   return node.type === 'RestElement';
 }
@@ -605,6 +659,18 @@ export function isTupleTypeAnnotation(node: ESNode | Token): boolean %checks {
   return node.type === 'TupleTypeAnnotation';
 }
 
+export function isTupleTypeLabeledElement(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'TupleTypeLabeledElement';
+}
+
+export function isTupleTypeSpreadElement(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'TupleTypeSpreadElement';
+}
+
 export function isTypeAlias(node: ESNode | Token): boolean %checks {
   return node.type === 'TypeAlias';
 }
@@ -637,6 +703,10 @@ export function isTypeParameterInstantiation(
   return node.type === 'TypeParameterInstantiation';
 }
 
+export function isTypePredicate(node: ESNode | Token): boolean %checks {
+  return node.type === 'TypePredicate';
+}
+
 export function isUnaryExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'UnaryExpression';
 }

package/dist/types.js.flow

@@ -174,17 +174,21 @@ export type ESNode =
   | TypeAnnotationType
   | Variance
   | FunctionTypeParam
+  | ComponentTypeParameter
   | InferredPredicate
   | ObjectTypeProperty
   | ObjectTypeCallProperty
   | ObjectTypeIndexer
   | ObjectTypeSpreadProperty
+  | ObjectTypeMappedTypeProperty
   | InterfaceExtends
   | ClassImplements
   | Decorator
   | TypeParameterDeclaration
   | TypeParameter
   | TypeParameterInstantiation
+  | ComponentDeclaration
+  | ComponentParameter
   | EnumDeclaration
   | EnumNumberBody
   | EnumStringBody
@@ -227,10 +231,13 @@ export type Statement =
   | BlockStatement
   | BreakStatement
   | ClassDeclaration
+  | ComponentDeclaration
   | ContinueStatement
   | DebuggerStatement
   | DeclareClass
+  | DeclareComponent
   | DeclareVariable
+  | DeclareEnum
   | DeclareFunction
   | DeclareInterface
   | DeclareModule
@@ -377,6 +384,24 @@ export interface DebuggerStatement extends BaseNode {
   +type: 'DebuggerStatement';
 }
 
+type ComponentParameterAndRestElement = ComponentParameter | RestElement;
+
+export interface ComponentParameter extends BaseNode {
+  +type: 'ComponentParameter';
+  +name: Identifier | StringLiteral;
+  +local: BindingName | AssignmentPattern;
+  +shorthand: boolean;
+}
+
+export interface ComponentDeclaration extends BaseNode {
+  +type: 'ComponentDeclaration';
+  +body: BlockStatement;
+  +id: Identifier;
+  +params: $ReadOnlyArray<ComponentParameterAndRestElement>;
+  +returnType: null | TypeAnnotation;
+  +typeParameters: null | TypeParameterDeclaration;
+}
+
 export interface FunctionDeclaration extends BaseFunction {
   +type: 'FunctionDeclaration';
   /** It is null when a function declaration is a part of the `export default function` statement */
@@ -619,7 +644,6 @@ export type MemberExpression =
   | MemberExpressionWithNonComputedName;
 export interface MemberExpressionWithComputedName extends BaseNode {
   +type: 'MemberExpression';
-  +computed: true;
   +object: Expression | Super;
   +property: Expression;
   +computed: true;
@@ -627,7 +651,6 @@ export interface MemberExpressionWithComputedName extends BaseNode {
 }
 export interface MemberExpressionWithNonComputedName extends BaseNode {
   +type: 'MemberExpression';
-  +computed: false;
   +object: Expression | Super;
   +property: Identifier | PrivateIdentifier;
   +computed: false;
@@ -1021,7 +1044,10 @@ export interface ImportNamespaceSpecifier extends BaseNode {
   +parent: ImportDeclaration;
 }
 
-export type DefaultDeclaration = FunctionDeclaration | ClassDeclaration;
+export type DefaultDeclaration =
+  | FunctionDeclaration
+  | ClassDeclaration
+  | ComponentDeclaration;
 export type NamedDeclaration =
   | DefaultDeclaration
   | VariableDeclaration
@@ -1103,12 +1129,20 @@ export type TypeAnnotationType =
   | ExistsTypeAnnotation
   | GenericTypeAnnotation
   | QualifiedTypeIdentifier
+  | QualifiedTypeofIdentifier
   | TypeofTypeAnnotation
+  | KeyofTypeAnnotation
   | TupleTypeAnnotation
+  | TupleTypeSpreadElement
+  | TupleTypeLabeledElement
+  | InferTypeAnnotation
   | InterfaceTypeAnnotation
   | UnionTypeAnnotation
   | IntersectionTypeAnnotation
+  | ConditionalTypeAnnotation
+  | TypePredicate
   | FunctionTypeAnnotation
+  | ComponentTypeAnnotation
   | ObjectTypeAnnotation
   | IndexedAccessType
   | OptionalIndexedAccessType;
@@ -1218,14 +1252,40 @@ export interface QualifiedTypeIdentifier extends BaseNode {
   +id: Identifier;
   +qualification: QualifiedTypeIdentifier | Identifier;
 }
+export interface QualifiedTypeofIdentifier extends BaseNode {
+  +type: 'QualifiedTypeofIdentifier';
+  +id: Identifier;
+  +qualification: QualifiedTypeofIdentifier | Identifier;
+}
 export interface TypeofTypeAnnotation extends BaseNode {
   +type: 'TypeofTypeAnnotation';
+  +argument: QualifiedTypeofIdentifier | Identifier;
+}
+export interface KeyofTypeAnnotation extends BaseNode {
+  +type: 'KeyofTypeAnnotation';
   +argument: TypeAnnotationType;
 }
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
   +types: $ReadOnlyArray<TypeAnnotationType>;
 }
+export interface TupleTypeSpreadElement extends BaseNode {
+  +type: 'TupleTypeSpreadElement';
+  +label?: Identifier | null;
+  +typeAnnotation: TypeAnnotationType;
+}
+export interface TupleTypeLabeledElement extends BaseNode {
+  +type: 'TupleTypeLabeledElement';
+  +label: Identifier;
+  +elementType: TypeAnnotationType;
+  +optional: boolean;
+  +variance: Variance | null;
+}
+
+export interface InferTypeAnnotation extends BaseNode {
+  +type: 'InferTypeAnnotation';
+  +typeParameter: TypeParameter;
+}
 
 // type T = { [[foo]]: number };
 export interface ObjectTypeInternalSlot extends BaseNode {
@@ -1252,6 +1312,21 @@ export interface IntersectionTypeAnnotation extends BaseNode {
   +types: $ReadOnlyArray<TypeAnnotationType>;
 }
 
+export interface ConditionalTypeAnnotation extends BaseNode {
+  +type: 'ConditionalTypeAnnotation';
+  +checkType: TypeAnnotationType;
+  +extendsType: TypeAnnotationType;
+  +trueType: TypeAnnotationType;
+  +falseType: TypeAnnotationType;
+}
+
+export interface TypePredicate extends BaseNode {
+  +type: 'TypePredicate';
+  +parameterName: Identifier;
+  +typeAnnotation: TypeAnnotationType | null;
+  +asserts: boolean;
+}
+
 export interface FunctionTypeAnnotation extends BaseNode {
   +type: 'FunctionTypeAnnotation';
   +params: $ReadOnlyArray<FunctionTypeParam>;
@@ -1268,6 +1343,23 @@ export interface FunctionTypeParam extends BaseNode {
 
   +parent: FunctionTypeAnnotation;
 }
+
+export interface ComponentTypeAnnotation extends BaseNode {
+  +type: 'ComponentTypeAnnotation';
+  +params: $ReadOnlyArray<ComponentTypeParameter>;
+  +rest: null | ComponentTypeParameter;
+  +typeParameters: null | TypeParameterDeclaration;
+  +returnType: null | TypeAnnotationType;
+}
+export interface ComponentTypeParameter extends BaseNode {
+  +type: 'ComponentTypeParameter';
+  +name: Identifier | StringLiteral | null;
+  +typeAnnotation: TypeAnnotationType | null;
+  +optional: boolean;
+
+  +parent: ComponentTypeAnnotation | DeclareComponent;
+}
+
 export interface InferredPredicate extends BaseNode {
   +type: 'InferredPredicate';
 
@@ -1278,7 +1370,11 @@ export interface ObjectTypeAnnotation extends BaseNode {
   +type: 'ObjectTypeAnnotation';
   +inexact: false;
   +exact: boolean;
-  +properties: $ReadOnlyArray<ObjectTypeProperty | ObjectTypeSpreadProperty>;
+  +properties: $ReadOnlyArray<
+    | ObjectTypeProperty
+    | ObjectTypeSpreadProperty
+    | ObjectTypeMappedTypeProperty,
+  >;
   +indexers: $ReadOnlyArray<ObjectTypeIndexer>;
   +callProperties: $ReadOnlyArray<ObjectTypeCallProperty>;
   +internalSlots: $ReadOnlyArray<ObjectTypeInternalSlot>;
@@ -1348,6 +1444,17 @@ export interface ObjectTypeIndexer extends BaseNode {
 
   +parent: ObjectTypeAnnotation;
 }
+export interface ObjectTypeMappedTypeProperty extends BaseNode {
+  +type: 'ObjectTypeMappedTypeProperty';
+  +keyTparam: TypeParameter;
+  +propType: TypeAnnotationType;
+  +sourceType: TypeAnnotationType;
+  +variance: null | Variance;
+  +optional: null | 'PlusOptional' | 'MinusOptional' | 'Optional';
+
+  +parent: ObjectTypeAnnotation;
+}
+
 export interface ObjectTypeSpreadProperty extends BaseNode {
   +type: 'ObjectTypeSpreadProperty';
   +argument: TypeAnnotationType;
@@ -1511,7 +1618,9 @@ export interface EnumDefaultedMember extends BaseNode {
 
 export type DeclaredNode =
   | DeclareClass
+  | DeclareComponent
   | DeclareVariable
+  | DeclareEnum
   | DeclareFunction
   | DeclareModule
   | DeclareInterface
@@ -1532,9 +1641,25 @@ export interface DeclareClass extends BaseNode {
   +mixins: $ReadOnlyArray<InterfaceExtends>;
 }
 
+export interface DeclareComponent extends BaseNode {
+  +type: 'DeclareComponent';
+  +id: Identifier;
+  +params: Array<ComponentTypeParameter>;
+  +rest: null | ComponentTypeParameter;
+  +typeParameters: null | TypeParameterDeclaration;
+  +returnType: null | TypeAnnotation;
+}
+
 export interface DeclareVariable extends BaseNode {
   +type: 'DeclareVariable';
   +id: Identifier;
+  +kind: 'var' | 'let' | 'const';
+}
+
+export interface DeclareEnum extends BaseNode {
+  +type: 'DeclareEnum';
+  +id: Identifier;
+  +body: EnumNumberBody | EnumStringBody | EnumBooleanBody | EnumSymbolBody;
 }
 
 export interface DeclareFunction extends BaseNode {
@@ -1597,7 +1722,8 @@ export interface DeclareExportDeclarationNamedWithDeclaration
     | DeclareFunction
     | DeclareInterface
     | DeclareOpaqueType
-    | DeclareVariable;
+    | DeclareVariable
+    | DeclareEnum;
   +default: false;
   +source: null;
   // default cannot have specifiers and a declaration
@@ -1726,6 +1852,7 @@ export interface JSXOpeningElement extends BaseNode {
   +selfClosing: boolean;
   +name: JSXTagNameExpression;
   +attributes: $ReadOnlyArray<JSXAttribute | JSXSpreadAttribute>;
+  +typeArguments?: TypeParameterInstantiation | null;
 
   +parent: JSXElement;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",