hermes-estree 0.33.3 → 0.35.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -70,6 +70,7 @@ import type {
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
+  Decorator,
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
@@ -251,16 +252,20 @@ interface ArrowFunctionExpression_With_params extends ArrowFunctionExpression {
 interface ArrowFunctionExpression_With_body extends ArrowFunctionExpression {
   +body: $NonMaybeType<ArrowFunctionExpression['body']>;
 }
-interface ArrowFunctionExpression_With_typeParameters extends ArrowFunctionExpression {
+interface ArrowFunctionExpression_With_typeParameters
+  extends ArrowFunctionExpression {
   +typeParameters: $NonMaybeType<ArrowFunctionExpression['typeParameters']>;
 }
-interface ArrowFunctionExpression_With_returnType extends ArrowFunctionExpression {
+interface ArrowFunctionExpression_With_returnType
+  extends ArrowFunctionExpression {
   +returnType: $NonMaybeType<ArrowFunctionExpression['returnType']>;
 }
-interface ArrowFunctionExpression_With_predicate extends ArrowFunctionExpression {
+interface ArrowFunctionExpression_With_predicate
+  extends ArrowFunctionExpression {
   +predicate: $NonMaybeType<ArrowFunctionExpression['predicate']>;
 }
-interface ArrowFunctionExpression_With_expression extends ArrowFunctionExpression {
+interface ArrowFunctionExpression_With_expression
+  extends ArrowFunctionExpression {
   +expression: $NonMaybeType<ArrowFunctionExpression['expression']>;
 }
 interface ArrowFunctionExpression_With_async extends ArrowFunctionExpression {
@@ -293,7 +298,8 @@ interface AssignmentPattern_With_right extends AssignmentPattern {
 interface AwaitExpression_With_argument extends AwaitExpression {
   +argument: $NonMaybeType<AwaitExpression['argument']>;
 }
-interface BigIntLiteralTypeAnnotation_With_raw extends BigIntLiteralTypeAnnotation {
+interface BigIntLiteralTypeAnnotation_With_raw
+  extends BigIntLiteralTypeAnnotation {
   +raw: $NonMaybeType<BigIntLiteralTypeAnnotation['raw']>;
 }
 interface BinaryExpression_With_left extends BinaryExpression {
@@ -311,10 +317,12 @@ interface BlockStatement_With_body extends BlockStatement {
 interface BlockStatement_With_implicit extends BlockStatement {
   +implicit: $NonMaybeType<BlockStatement['implicit']>;
 }
-interface BooleanLiteralTypeAnnotation_With_value extends BooleanLiteralTypeAnnotation {
+interface BooleanLiteralTypeAnnotation_With_value
+  extends BooleanLiteralTypeAnnotation {
   +value: $NonMaybeType<BooleanLiteralTypeAnnotation['value']>;
 }
-interface BooleanLiteralTypeAnnotation_With_raw extends BooleanLiteralTypeAnnotation {
+interface BooleanLiteralTypeAnnotation_With_raw
+  extends BooleanLiteralTypeAnnotation {
   +raw: $NonMaybeType<BooleanLiteralTypeAnnotation['raw']>;
 }
 interface BreakStatement_With_label extends BreakStatement {
@@ -398,12 +406,16 @@ interface ComponentDeclaration_With_params extends ComponentDeclaration {
 interface ComponentDeclaration_With_body extends ComponentDeclaration {
   +body: $NonMaybeType<ComponentDeclaration['body']>;
 }
-interface ComponentDeclaration_With_typeParameters extends ComponentDeclaration {
+interface ComponentDeclaration_With_typeParameters
+  extends ComponentDeclaration {
   +typeParameters: $NonMaybeType<ComponentDeclaration['typeParameters']>;
 }
 interface ComponentDeclaration_With_rendersType extends ComponentDeclaration {
   +rendersType: $NonMaybeType<ComponentDeclaration['rendersType']>;
 }
+interface ComponentDeclaration_With_async extends ComponentDeclaration {
+  +async: $NonMaybeType<ComponentDeclaration['async']>;
+}
 interface ComponentParameter_With_name extends ComponentParameter {
   +name: $NonMaybeType<ComponentParameter['name']>;
 }
@@ -419,16 +431,19 @@ interface ComponentTypeAnnotation_With_params extends ComponentTypeAnnotation {
 interface ComponentTypeAnnotation_With_rest extends ComponentTypeAnnotation {
   +rest: $NonMaybeType<ComponentTypeAnnotation['rest']>;
 }
-interface ComponentTypeAnnotation_With_typeParameters extends ComponentTypeAnnotation {
+interface ComponentTypeAnnotation_With_typeParameters
+  extends ComponentTypeAnnotation {
   +typeParameters: $NonMaybeType<ComponentTypeAnnotation['typeParameters']>;
 }
-interface ComponentTypeAnnotation_With_rendersType extends ComponentTypeAnnotation {
+interface ComponentTypeAnnotation_With_rendersType
+  extends ComponentTypeAnnotation {
   +rendersType: $NonMaybeType<ComponentTypeAnnotation['rendersType']>;
 }
 interface ComponentTypeParameter_With_name extends ComponentTypeParameter {
   +name: $NonMaybeType<ComponentTypeParameter['name']>;
 }
-interface ComponentTypeParameter_With_typeAnnotation extends ComponentTypeParameter {
+interface ComponentTypeParameter_With_typeAnnotation
+  extends ComponentTypeParameter {
   +typeAnnotation: $NonMaybeType<ComponentTypeParameter['typeAnnotation']>;
 }
 interface ComponentTypeParameter_With_optional extends ComponentTypeParameter {
@@ -443,16 +458,20 @@ interface ConditionalExpression_With_alternate extends ConditionalExpression {
 interface ConditionalExpression_With_consequent extends ConditionalExpression {
   +consequent: $NonMaybeType<ConditionalExpression['consequent']>;
 }
-interface ConditionalTypeAnnotation_With_checkType extends ConditionalTypeAnnotation {
+interface ConditionalTypeAnnotation_With_checkType
+  extends ConditionalTypeAnnotation {
   +checkType: $NonMaybeType<ConditionalTypeAnnotation['checkType']>;
 }
-interface ConditionalTypeAnnotation_With_extendsType extends ConditionalTypeAnnotation {
+interface ConditionalTypeAnnotation_With_extendsType
+  extends ConditionalTypeAnnotation {
   +extendsType: $NonMaybeType<ConditionalTypeAnnotation['extendsType']>;
 }
-interface ConditionalTypeAnnotation_With_trueType extends ConditionalTypeAnnotation {
+interface ConditionalTypeAnnotation_With_trueType
+  extends ConditionalTypeAnnotation {
   +trueType: $NonMaybeType<ConditionalTypeAnnotation['trueType']>;
 }
-interface ConditionalTypeAnnotation_With_falseType extends ConditionalTypeAnnotation {
+interface ConditionalTypeAnnotation_With_falseType
+  extends ConditionalTypeAnnotation {
   +falseType: $NonMaybeType<ConditionalTypeAnnotation['falseType']>;
 }
 interface ContinueStatement_With_label extends ContinueStatement {
@@ -500,19 +519,24 @@ interface DeclareEnum_With_id extends DeclareEnum {
 interface DeclareEnum_With_body extends DeclareEnum {
   +body: $NonMaybeType<DeclareEnum['body']>;
 }
-interface DeclareExportAllDeclaration_With_source extends DeclareExportAllDeclaration {
+interface DeclareExportAllDeclaration_With_source
+  extends DeclareExportAllDeclaration {
   +source: $NonMaybeType<DeclareExportAllDeclaration['source']>;
 }
-interface DeclareExportDeclaration_With_declaration extends DeclareExportDeclaration {
+interface DeclareExportDeclaration_With_declaration
+  extends DeclareExportDeclaration {
   +declaration: $NonMaybeType<DeclareExportDeclaration['declaration']>;
 }
-interface DeclareExportDeclaration_With_specifiers extends DeclareExportDeclaration {
+interface DeclareExportDeclaration_With_specifiers
+  extends DeclareExportDeclaration {
   +specifiers: $NonMaybeType<DeclareExportDeclaration['specifiers']>;
 }
-interface DeclareExportDeclaration_With_source extends DeclareExportDeclaration {
+interface DeclareExportDeclaration_With_source
+  extends DeclareExportDeclaration {
   +source: $NonMaybeType<DeclareExportDeclaration['source']>;
 }
-interface DeclareExportDeclaration_With_default extends DeclareExportDeclaration {
+interface DeclareExportDeclaration_With_default
+  extends DeclareExportDeclaration {
   +default: $NonMaybeType<DeclareExportDeclaration['default']>;
 }
 interface DeclareFunction_With_id extends DeclareFunction {
@@ -542,7 +566,8 @@ interface DeclareModule_With_id extends DeclareModule {
 interface DeclareModule_With_body extends DeclareModule {
   +body: $NonMaybeType<DeclareModule['body']>;
 }
-interface DeclareModuleExports_With_typeAnnotation extends DeclareModuleExports {
+interface DeclareModuleExports_With_typeAnnotation
+  extends DeclareModuleExports {
   +typeAnnotation: $NonMaybeType<DeclareModuleExports['typeAnnotation']>;
 }
 interface DeclareNamespace_With_id extends DeclareNamespace {
@@ -584,6 +609,9 @@ interface DeclareVariable_With_id extends DeclareVariable {
 interface DeclareVariable_With_kind extends DeclareVariable {
   +kind: $NonMaybeType<DeclareVariable['kind']>;
 }
+interface Decorator_With_expression extends Decorator {
+  +expression: $NonMaybeType<Decorator['expression']>;
+}
 interface DoWhileStatement_With_body extends DoWhileStatement {
   +body: $NonMaybeType<DoWhileStatement['body']>;
 }
@@ -674,19 +702,23 @@ interface ExportAllDeclaration_With_source extends ExportAllDeclaration {
 interface ExportAllDeclaration_With_exportKind extends ExportAllDeclaration {
   +exportKind: $NonMaybeType<ExportAllDeclaration['exportKind']>;
 }
-interface ExportDefaultDeclaration_With_declaration extends ExportDefaultDeclaration {
+interface ExportDefaultDeclaration_With_declaration
+  extends ExportDefaultDeclaration {
   +declaration: $NonMaybeType<ExportDefaultDeclaration['declaration']>;
 }
-interface ExportNamedDeclaration_With_declaration extends ExportNamedDeclaration {
+interface ExportNamedDeclaration_With_declaration
+  extends ExportNamedDeclaration {
   +declaration: $NonMaybeType<ExportNamedDeclaration['declaration']>;
 }
-interface ExportNamedDeclaration_With_specifiers extends ExportNamedDeclaration {
+interface ExportNamedDeclaration_With_specifiers
+  extends ExportNamedDeclaration {
   +specifiers: $NonMaybeType<ExportNamedDeclaration['specifiers']>;
 }
 interface ExportNamedDeclaration_With_source extends ExportNamedDeclaration {
   +source: $NonMaybeType<ExportNamedDeclaration['source']>;
 }
-interface ExportNamedDeclaration_With_exportKind extends ExportNamedDeclaration {
+interface ExportNamedDeclaration_With_exportKind
+  extends ExportNamedDeclaration {
   +exportKind: $NonMaybeType<ExportNamedDeclaration['exportKind']>;
 }
 interface ExportSpecifier_With_exported extends ExportSpecifier {
@@ -788,13 +820,15 @@ interface FunctionTypeAnnotation_With_params extends FunctionTypeAnnotation {
 interface FunctionTypeAnnotation_With_this extends FunctionTypeAnnotation {
   +this: $NonMaybeType<FunctionTypeAnnotation['this']>;
 }
-interface FunctionTypeAnnotation_With_returnType extends FunctionTypeAnnotation {
+interface FunctionTypeAnnotation_With_returnType
+  extends FunctionTypeAnnotation {
   +returnType: $NonMaybeType<FunctionTypeAnnotation['returnType']>;
 }
 interface FunctionTypeAnnotation_With_rest extends FunctionTypeAnnotation {
   +rest: $NonMaybeType<FunctionTypeAnnotation['rest']>;
 }
-interface FunctionTypeAnnotation_With_typeParameters extends FunctionTypeAnnotation {
+interface FunctionTypeAnnotation_With_typeParameters
+  extends FunctionTypeAnnotation {
   +typeParameters: $NonMaybeType<FunctionTypeAnnotation['typeParameters']>;
 }
 interface FunctionTypeParam_With_name extends FunctionTypeParam {
@@ -809,7 +843,8 @@ interface FunctionTypeParam_With_optional extends FunctionTypeParam {
 interface GenericTypeAnnotation_With_id extends GenericTypeAnnotation {
   +id: $NonMaybeType<GenericTypeAnnotation['id']>;
 }
-interface GenericTypeAnnotation_With_typeParameters extends GenericTypeAnnotation {
+interface GenericTypeAnnotation_With_typeParameters
+  extends GenericTypeAnnotation {
   +typeParameters: $NonMaybeType<GenericTypeAnnotation['typeParameters']>;
 }
 interface HookDeclaration_With_id extends HookDeclaration {
@@ -827,6 +862,9 @@ interface HookDeclaration_With_typeParameters extends HookDeclaration {
 interface HookDeclaration_With_returnType extends HookDeclaration {
   +returnType: $NonMaybeType<HookDeclaration['returnType']>;
 }
+interface HookDeclaration_With_async extends HookDeclaration {
+  +async: $NonMaybeType<HookDeclaration['async']>;
+}
 interface HookTypeAnnotation_With_params extends HookTypeAnnotation {
   +params: $NonMaybeType<HookTypeAnnotation['params']>;
 }
@@ -869,8 +907,8 @@ interface ImportDeclaration_With_specifiers extends ImportDeclaration {
 interface ImportDeclaration_With_source extends ImportDeclaration {
   +source: $NonMaybeType<ImportDeclaration['source']>;
 }
-interface ImportDeclaration_With_assertions extends ImportDeclaration {
-  +assertions: $NonMaybeType<ImportDeclaration['assertions']>;
+interface ImportDeclaration_With_attributes extends ImportDeclaration {
+  +attributes: $NonMaybeType<ImportDeclaration['attributes']>;
 }
 interface ImportDeclaration_With_importKind extends ImportDeclaration {
   +importKind: $NonMaybeType<ImportDeclaration['importKind']>;
@@ -908,7 +946,8 @@ interface InferTypeAnnotation_With_typeParameter extends InferTypeAnnotation {
 interface InterfaceDeclaration_With_id extends InterfaceDeclaration {
   +id: $NonMaybeType<InterfaceDeclaration['id']>;
 }
-interface InterfaceDeclaration_With_typeParameters extends InterfaceDeclaration {
+interface InterfaceDeclaration_With_typeParameters
+  extends InterfaceDeclaration {
   +typeParameters: $NonMaybeType<InterfaceDeclaration['typeParameters']>;
 }
 interface InterfaceDeclaration_With_extends extends InterfaceDeclaration {
@@ -929,7 +968,8 @@ interface InterfaceTypeAnnotation_With_extends extends InterfaceTypeAnnotation {
 interface InterfaceTypeAnnotation_With_body extends InterfaceTypeAnnotation {
   +body: $NonMaybeType<InterfaceTypeAnnotation['body']>;
 }
-interface IntersectionTypeAnnotation_With_types extends IntersectionTypeAnnotation {
+interface IntersectionTypeAnnotation_With_types
+  extends IntersectionTypeAnnotation {
   +types: $NonMaybeType<IntersectionTypeAnnotation['types']>;
 }
 interface JSXAttribute_With_name extends JSXAttribute {
@@ -950,7 +990,8 @@ interface JSXElement_With_children extends JSXElement {
 interface JSXElement_With_closingElement extends JSXElement {
   +closingElement: $NonMaybeType<JSXElement['closingElement']>;
 }
-interface JSXExpressionContainer_With_expression extends JSXExpressionContainer {
+interface JSXExpressionContainer_With_expression
+  extends JSXExpressionContainer {
   +expression: $NonMaybeType<JSXExpressionContainer['expression']>;
 }
 interface JSXFragment_With_openingFragment extends JSXFragment {
@@ -1055,13 +1096,16 @@ interface MatchExpressionCase_With_guard extends MatchExpressionCase {
 interface MatchIdentifierPattern_With_id extends MatchIdentifierPattern {
   +id: $NonMaybeType<MatchIdentifierPattern['id']>;
 }
-interface MatchInstanceObjectPattern_With_properties extends MatchInstanceObjectPattern {
+interface MatchInstanceObjectPattern_With_properties
+  extends MatchInstanceObjectPattern {
   +properties: $NonMaybeType<MatchInstanceObjectPattern['properties']>;
 }
-interface MatchInstanceObjectPattern_With_rest extends MatchInstanceObjectPattern {
+interface MatchInstanceObjectPattern_With_rest
+  extends MatchInstanceObjectPattern {
   +rest: $NonMaybeType<MatchInstanceObjectPattern['rest']>;
 }
-interface MatchInstancePattern_With_targetConstructor extends MatchInstancePattern {
+interface MatchInstancePattern_With_targetConstructor
+  extends MatchInstancePattern {
   +targetConstructor: $NonMaybeType<MatchInstancePattern['targetConstructor']>;
 }
 interface MatchInstancePattern_With_properties extends MatchInstancePattern {
@@ -1082,13 +1126,16 @@ interface MatchObjectPattern_With_properties extends MatchObjectPattern {
 interface MatchObjectPattern_With_rest extends MatchObjectPattern {
   +rest: $NonMaybeType<MatchObjectPattern['rest']>;
 }
-interface MatchObjectPatternProperty_With_key extends MatchObjectPatternProperty {
+interface MatchObjectPatternProperty_With_key
+  extends MatchObjectPatternProperty {
   +key: $NonMaybeType<MatchObjectPatternProperty['key']>;
 }
-interface MatchObjectPatternProperty_With_pattern extends MatchObjectPatternProperty {
+interface MatchObjectPatternProperty_With_pattern
+  extends MatchObjectPatternProperty {
   +pattern: $NonMaybeType<MatchObjectPatternProperty['pattern']>;
 }
-interface MatchObjectPatternProperty_With_shorthand extends MatchObjectPatternProperty {
+interface MatchObjectPatternProperty_With_shorthand
+  extends MatchObjectPatternProperty {
   +shorthand: $NonMaybeType<MatchObjectPatternProperty['shorthand']>;
 }
 interface MatchOrPattern_With_patterns extends MatchOrPattern {
@@ -1148,6 +1195,9 @@ interface MethodDefinition_With_computed extends MethodDefinition {
 interface MethodDefinition_With_static extends MethodDefinition {
   +static: $NonMaybeType<MethodDefinition['static']>;
 }
+interface MethodDefinition_With_decorators extends MethodDefinition {
+  +decorators: $NonMaybeType<MethodDefinition['decorators']>;
+}
 interface NewExpression_With_callee extends NewExpression {
   +callee: $NonMaybeType<NewExpression['callee']>;
 }
@@ -1157,13 +1207,16 @@ interface NewExpression_With_typeArguments extends NewExpression {
 interface NewExpression_With_arguments extends NewExpression {
   +arguments: $NonMaybeType<NewExpression['arguments']>;
 }
-interface NullableTypeAnnotation_With_typeAnnotation extends NullableTypeAnnotation {
+interface NullableTypeAnnotation_With_typeAnnotation
+  extends NullableTypeAnnotation {
   +typeAnnotation: $NonMaybeType<NullableTypeAnnotation['typeAnnotation']>;
 }
-interface NumberLiteralTypeAnnotation_With_value extends NumberLiteralTypeAnnotation {
+interface NumberLiteralTypeAnnotation_With_value
+  extends NumberLiteralTypeAnnotation {
   +value: $NonMaybeType<NumberLiteralTypeAnnotation['value']>;
 }
-interface NumberLiteralTypeAnnotation_With_raw extends NumberLiteralTypeAnnotation {
+interface NumberLiteralTypeAnnotation_With_raw
+  extends NumberLiteralTypeAnnotation {
   +raw: $NonMaybeType<NumberLiteralTypeAnnotation['raw']>;
 }
 interface ObjectExpression_With_properties extends ObjectExpression {
@@ -1181,7 +1234,8 @@ interface ObjectTypeAnnotation_With_properties extends ObjectTypeAnnotation {
 interface ObjectTypeAnnotation_With_indexers extends ObjectTypeAnnotation {
   +indexers: $NonMaybeType<ObjectTypeAnnotation['indexers']>;
 }
-interface ObjectTypeAnnotation_With_callProperties extends ObjectTypeAnnotation {
+interface ObjectTypeAnnotation_With_callProperties
+  extends ObjectTypeAnnotation {
   +callProperties: $NonMaybeType<ObjectTypeAnnotation['callProperties']>;
 }
 interface ObjectTypeAnnotation_With_internalSlots extends ObjectTypeAnnotation {
@@ -1229,19 +1283,24 @@ interface ObjectTypeInternalSlot_With_static extends ObjectTypeInternalSlot {
 interface ObjectTypeInternalSlot_With_method extends ObjectTypeInternalSlot {
   +method: $NonMaybeType<ObjectTypeInternalSlot['method']>;
 }
-interface ObjectTypeMappedTypeProperty_With_keyTparam extends ObjectTypeMappedTypeProperty {
+interface ObjectTypeMappedTypeProperty_With_keyTparam
+  extends ObjectTypeMappedTypeProperty {
   +keyTparam: $NonMaybeType<ObjectTypeMappedTypeProperty['keyTparam']>;
 }
-interface ObjectTypeMappedTypeProperty_With_propType extends ObjectTypeMappedTypeProperty {
+interface ObjectTypeMappedTypeProperty_With_propType
+  extends ObjectTypeMappedTypeProperty {
   +propType: $NonMaybeType<ObjectTypeMappedTypeProperty['propType']>;
 }
-interface ObjectTypeMappedTypeProperty_With_sourceType extends ObjectTypeMappedTypeProperty {
+interface ObjectTypeMappedTypeProperty_With_sourceType
+  extends ObjectTypeMappedTypeProperty {
   +sourceType: $NonMaybeType<ObjectTypeMappedTypeProperty['sourceType']>;
 }
-interface ObjectTypeMappedTypeProperty_With_variance extends ObjectTypeMappedTypeProperty {
+interface ObjectTypeMappedTypeProperty_With_variance
+  extends ObjectTypeMappedTypeProperty {
   +variance: $NonMaybeType<ObjectTypeMappedTypeProperty['variance']>;
 }
-interface ObjectTypeMappedTypeProperty_With_optional extends ObjectTypeMappedTypeProperty {
+interface ObjectTypeMappedTypeProperty_With_optional
+  extends ObjectTypeMappedTypeProperty {
   +optional: $NonMaybeType<ObjectTypeMappedTypeProperty['optional']>;
 }
 interface ObjectTypeProperty_With_key extends ObjectTypeProperty {
@@ -1268,7 +1327,8 @@ interface ObjectTypeProperty_With_variance extends ObjectTypeProperty {
 interface ObjectTypeProperty_With_kind extends ObjectTypeProperty {
   +kind: $NonMaybeType<ObjectTypeProperty['kind']>;
 }
-interface ObjectTypeSpreadProperty_With_argument extends ObjectTypeSpreadProperty {
+interface ObjectTypeSpreadProperty_With_argument
+  extends ObjectTypeSpreadProperty {
   +argument: $NonMaybeType<ObjectTypeSpreadProperty['argument']>;
 }
 interface OpaqueType_With_id extends OpaqueType {
@@ -1289,13 +1349,16 @@ interface OpaqueType_With_upperBound extends OpaqueType {
 interface OpaqueType_With_supertype extends OpaqueType {
   +supertype: $NonMaybeType<OpaqueType['supertype']>;
 }
-interface OptionalIndexedAccessType_With_objectType extends OptionalIndexedAccessType {
+interface OptionalIndexedAccessType_With_objectType
+  extends OptionalIndexedAccessType {
   +objectType: $NonMaybeType<OptionalIndexedAccessType['objectType']>;
 }
-interface OptionalIndexedAccessType_With_indexType extends OptionalIndexedAccessType {
+interface OptionalIndexedAccessType_With_indexType
+  extends OptionalIndexedAccessType {
   +indexType: $NonMaybeType<OptionalIndexedAccessType['indexType']>;
 }
-interface OptionalIndexedAccessType_With_optional extends OptionalIndexedAccessType {
+interface OptionalIndexedAccessType_With_optional
+  extends OptionalIndexedAccessType {
   +optional: $NonMaybeType<OptionalIndexedAccessType['optional']>;
 }
 interface PrivateIdentifier_With_name extends PrivateIdentifier {
@@ -1334,6 +1397,9 @@ interface PropertyDefinition_With_computed extends PropertyDefinition {
 interface PropertyDefinition_With_static extends PropertyDefinition {
   +static: $NonMaybeType<PropertyDefinition['static']>;
 }
+interface PropertyDefinition_With_decorators extends PropertyDefinition {
+  +decorators: $NonMaybeType<PropertyDefinition['decorators']>;
+}
 interface PropertyDefinition_With_declare extends PropertyDefinition {
   +declare: $NonMaybeType<PropertyDefinition['declare']>;
 }
@@ -1349,13 +1415,15 @@ interface PropertyDefinition_With_typeAnnotation extends PropertyDefinition {
 interface PropertyDefinition_With_tsModifiers extends PropertyDefinition {
   +tsModifiers: $NonMaybeType<PropertyDefinition['tsModifiers']>;
 }
-interface QualifiedTypeIdentifier_With_qualification extends QualifiedTypeIdentifier {
+interface QualifiedTypeIdentifier_With_qualification
+  extends QualifiedTypeIdentifier {
   +qualification: $NonMaybeType<QualifiedTypeIdentifier['qualification']>;
 }
 interface QualifiedTypeIdentifier_With_id extends QualifiedTypeIdentifier {
   +id: $NonMaybeType<QualifiedTypeIdentifier['id']>;
 }
-interface QualifiedTypeofIdentifier_With_qualification extends QualifiedTypeofIdentifier {
+interface QualifiedTypeofIdentifier_With_qualification
+  extends QualifiedTypeofIdentifier {
   +qualification: $NonMaybeType<QualifiedTypeofIdentifier['qualification']>;
 }
 interface QualifiedTypeofIdentifier_With_id extends QualifiedTypeofIdentifier {
@@ -1376,30 +1444,37 @@ interface RecordDeclaration_With_body extends RecordDeclaration {
 interface RecordDeclarationBody_With_elements extends RecordDeclarationBody {
   +elements: $NonMaybeType<RecordDeclarationBody['elements']>;
 }
-interface RecordDeclarationImplements_With_id extends RecordDeclarationImplements {
+interface RecordDeclarationImplements_With_id
+  extends RecordDeclarationImplements {
   +id: $NonMaybeType<RecordDeclarationImplements['id']>;
 }
-interface RecordDeclarationImplements_With_typeArguments extends RecordDeclarationImplements {
+interface RecordDeclarationImplements_With_typeArguments
+  extends RecordDeclarationImplements {
   +typeArguments: $NonMaybeType<RecordDeclarationImplements['typeArguments']>;
 }
 interface RecordDeclarationProperty_With_key extends RecordDeclarationProperty {
   +key: $NonMaybeType<RecordDeclarationProperty['key']>;
 }
-interface RecordDeclarationProperty_With_typeAnnotation extends RecordDeclarationProperty {
+interface RecordDeclarationProperty_With_typeAnnotation
+  extends RecordDeclarationProperty {
   +typeAnnotation: $NonMaybeType<RecordDeclarationProperty['typeAnnotation']>;
 }
-interface RecordDeclarationProperty_With_defaultValue extends RecordDeclarationProperty {
+interface RecordDeclarationProperty_With_defaultValue
+  extends RecordDeclarationProperty {
   +defaultValue: $NonMaybeType<RecordDeclarationProperty['defaultValue']>;
 }
-interface RecordDeclarationStaticProperty_With_key extends RecordDeclarationStaticProperty {
+interface RecordDeclarationStaticProperty_With_key
+  extends RecordDeclarationStaticProperty {
   +key: $NonMaybeType<RecordDeclarationStaticProperty['key']>;
 }
-interface RecordDeclarationStaticProperty_With_typeAnnotation extends RecordDeclarationStaticProperty {
+interface RecordDeclarationStaticProperty_With_typeAnnotation
+  extends RecordDeclarationStaticProperty {
   +typeAnnotation: $NonMaybeType<
     RecordDeclarationStaticProperty['typeAnnotation'],
   >;
 }
-interface RecordDeclarationStaticProperty_With_value extends RecordDeclarationStaticProperty {
+interface RecordDeclarationStaticProperty_With_value
+  extends RecordDeclarationStaticProperty {
   +value: $NonMaybeType<RecordDeclarationStaticProperty['value']>;
 }
 interface RecordExpression_With_recordConstructor extends RecordExpression {
@@ -1411,7 +1486,8 @@ interface RecordExpression_With_typeArguments extends RecordExpression {
 interface RecordExpression_With_properties extends RecordExpression {
   +properties: $NonMaybeType<RecordExpression['properties']>;
 }
-interface RecordExpressionProperties_With_properties extends RecordExpressionProperties {
+interface RecordExpressionProperties_With_properties
+  extends RecordExpressionProperties {
   +properties: $NonMaybeType<RecordExpressionProperties['properties']>;
 }
 interface RestElement_With_argument extends RestElement {
@@ -1429,10 +1505,12 @@ interface SpreadElement_With_argument extends SpreadElement {
 interface StaticBlock_With_body extends StaticBlock {
   +body: $NonMaybeType<StaticBlock['body']>;
 }
-interface StringLiteralTypeAnnotation_With_value extends StringLiteralTypeAnnotation {
+interface StringLiteralTypeAnnotation_With_value
+  extends StringLiteralTypeAnnotation {
   +value: $NonMaybeType<StringLiteralTypeAnnotation['value']>;
 }
-interface StringLiteralTypeAnnotation_With_raw extends StringLiteralTypeAnnotation {
+interface StringLiteralTypeAnnotation_With_raw
+  extends StringLiteralTypeAnnotation {
   +raw: $NonMaybeType<StringLiteralTypeAnnotation['raw']>;
 }
 interface SwitchCase_With_test extends SwitchCase {
@@ -1489,19 +1567,23 @@ interface TupleTypeAnnotation_With_inexact extends TupleTypeAnnotation {
 interface TupleTypeLabeledElement_With_label extends TupleTypeLabeledElement {
   +label: $NonMaybeType<TupleTypeLabeledElement['label']>;
 }
-interface TupleTypeLabeledElement_With_elementType extends TupleTypeLabeledElement {
+interface TupleTypeLabeledElement_With_elementType
+  extends TupleTypeLabeledElement {
   +elementType: $NonMaybeType<TupleTypeLabeledElement['elementType']>;
 }
-interface TupleTypeLabeledElement_With_optional extends TupleTypeLabeledElement {
+interface TupleTypeLabeledElement_With_optional
+  extends TupleTypeLabeledElement {
   +optional: $NonMaybeType<TupleTypeLabeledElement['optional']>;
 }
-interface TupleTypeLabeledElement_With_variance extends TupleTypeLabeledElement {
+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 {
+interface TupleTypeSpreadElement_With_typeAnnotation
+  extends TupleTypeSpreadElement {
   +typeAnnotation: $NonMaybeType<TupleTypeSpreadElement['typeAnnotation']>;
 }
 interface TypeAlias_With_id extends TypeAlias {
@@ -1552,10 +1634,12 @@ interface TypeParameter_With_default extends TypeParameter {
 interface TypeParameter_With_usesExtendsBound extends TypeParameter {
   +usesExtendsBound: $NonMaybeType<TypeParameter['usesExtendsBound']>;
 }
-interface TypeParameterDeclaration_With_params extends TypeParameterDeclaration {
+interface TypeParameterDeclaration_With_params
+  extends TypeParameterDeclaration {
   +params: $NonMaybeType<TypeParameterDeclaration['params']>;
 }
-interface TypeParameterInstantiation_With_params extends TypeParameterInstantiation {
+interface TypeParameterInstantiation_With_params
+  extends TypeParameterInstantiation {
   +params: $NonMaybeType<TypeParameterInstantiation['params']>;
 }
 interface TypePredicate_With_parameterName extends TypePredicate {
@@ -1868,6 +1952,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ComponentDeclaration[rendersType]'?: (
     node: ComponentDeclaration_With_rendersType,
   ) => void,
+  +'ComponentDeclaration[async]'?: (
+    node: ComponentDeclaration_With_async,
+  ) => void,
   +ComponentParameter?: (node: ComponentParameter) => void,
   +'ComponentParameter[name]'?: (node: ComponentParameter_With_name) => void,
   +'ComponentParameter[local]'?: (node: ComponentParameter_With_local) => void,
@@ -2014,6 +2101,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +DeclareVariable?: (node: DeclareVariable) => void,
   +'DeclareVariable[id]'?: (node: DeclareVariable_With_id) => void,
   +'DeclareVariable[kind]'?: (node: DeclareVariable_With_kind) => void,
+  +Decorator?: (node: Decorator) => void,
+  +'Decorator[expression]'?: (node: Decorator_With_expression) => void,
   +DoWhileStatement?: (node: DoWhileStatement) => void,
   +'DoWhileStatement[body]'?: (node: DoWhileStatement_With_body) => void,
   +'DoWhileStatement[test]'?: (node: DoWhileStatement_With_test) => void,
@@ -2204,6 +2293,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'HookDeclaration[returnType]'?: (
     node: HookDeclaration_With_returnType,
   ) => void,
+  +'HookDeclaration[async]'?: (node: HookDeclaration_With_async) => void,
   +HookTypeAnnotation?: (node: HookTypeAnnotation) => void,
   +'HookTypeAnnotation[params]'?: (
     node: HookTypeAnnotation_With_params,
@@ -2233,8 +2323,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
     node: ImportDeclaration_With_specifiers,
   ) => void,
   +'ImportDeclaration[source]'?: (node: ImportDeclaration_With_source) => void,
-  +'ImportDeclaration[assertions]'?: (
-    node: ImportDeclaration_With_assertions,
+  +'ImportDeclaration[attributes]'?: (
+    node: ImportDeclaration_With_attributes,
   ) => void,
   +'ImportDeclaration[importKind]'?: (
     node: ImportDeclaration_With_importKind,
@@ -2478,6 +2568,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
     node: MethodDefinition_With_computed,
   ) => void,
   +'MethodDefinition[static]'?: (node: MethodDefinition_With_static) => void,
+  +'MethodDefinition[decorators]'?: (
+    node: MethodDefinition_With_decorators,
+  ) => void,
   +MixedTypeAnnotation?: (node: MixedTypeAnnotation) => void,
   +NeverTypeAnnotation?: (node: NeverTypeAnnotation) => void,
   +NewExpression?: (node: NewExpression) => void,
@@ -2634,6 +2727,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[static]'?: (
     node: PropertyDefinition_With_static,
   ) => void,
+  +'PropertyDefinition[decorators]'?: (
+    node: PropertyDefinition_With_decorators,
+  ) => void,
   +'PropertyDefinition[declare]'?: (
     node: PropertyDefinition_With_declare,
   ) => void,
@@ -3070,6 +3166,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ComponentDeclaration[rendersType]:exit'?: (
     node: ComponentDeclaration_With_rendersType,
   ) => void,
+  +'ComponentDeclaration[async]:exit'?: (
+    node: ComponentDeclaration_With_async,
+  ) => void,
   +'ComponentParameter:exit'?: (node: ComponentParameter) => void,
   +'ComponentParameter[name]:exit'?: (
     node: ComponentParameter_With_name,
@@ -3232,6 +3331,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DeclareVariable:exit'?: (node: DeclareVariable) => void,
   +'DeclareVariable[id]:exit'?: (node: DeclareVariable_With_id) => void,
   +'DeclareVariable[kind]:exit'?: (node: DeclareVariable_With_kind) => void,
+  +'Decorator:exit'?: (node: Decorator) => void,
+  +'Decorator[expression]:exit'?: (node: Decorator_With_expression) => void,
   +'DoWhileStatement:exit'?: (node: DoWhileStatement) => void,
   +'DoWhileStatement[body]:exit'?: (node: DoWhileStatement_With_body) => void,
   +'DoWhileStatement[test]:exit'?: (node: DoWhileStatement_With_test) => void,
@@ -3434,6 +3535,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'HookDeclaration[returnType]:exit'?: (
     node: HookDeclaration_With_returnType,
   ) => void,
+  +'HookDeclaration[async]:exit'?: (node: HookDeclaration_With_async) => void,
   +'HookTypeAnnotation:exit'?: (node: HookTypeAnnotation) => void,
   +'HookTypeAnnotation[params]:exit'?: (
     node: HookTypeAnnotation_With_params,
@@ -3467,8 +3569,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ImportDeclaration[source]:exit'?: (
     node: ImportDeclaration_With_source,
   ) => void,
-  +'ImportDeclaration[assertions]:exit'?: (
-    node: ImportDeclaration_With_assertions,
+  +'ImportDeclaration[attributes]:exit'?: (
+    node: ImportDeclaration_With_attributes,
   ) => void,
   +'ImportDeclaration[importKind]:exit'?: (
     node: ImportDeclaration_With_importKind,
@@ -3750,6 +3852,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'MethodDefinition[static]:exit'?: (
     node: MethodDefinition_With_static,
   ) => void,
+  +'MethodDefinition[decorators]:exit'?: (
+    node: MethodDefinition_With_decorators,
+  ) => void,
   +'MixedTypeAnnotation:exit'?: (node: MixedTypeAnnotation) => void,
   +'NeverTypeAnnotation:exit'?: (node: NeverTypeAnnotation) => void,
   +'NewExpression:exit'?: (node: NewExpression) => void,
@@ -3926,6 +4031,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[static]:exit'?: (
     node: PropertyDefinition_With_static,
   ) => void,
+  +'PropertyDefinition[decorators]:exit'?: (
+    node: PropertyDefinition_With_decorators,
+  ) => void,
   +'PropertyDefinition[declare]:exit'?: (
     node: PropertyDefinition_With_declare,
   ) => void,

package/dist/generated/predicates.js

@@ -81,6 +81,7 @@ import type {
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
+  Decorator,
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
@@ -322,6 +323,7 @@ exports.isDeclareOpaqueType = isDeclareOpaqueType;
 exports.isDeclareTypeAlias = isDeclareTypeAlias;
 exports.isDeclareVariable = isDeclareVariable;
 exports.isDeclaredPredicate = isDeclaredPredicate;
+exports.isDecorator = isDecorator;
 exports.isDecrementToken = isDecrementToken;
 exports.isDefaultToken = isDefaultToken;
 exports.isDeleteToken = isDeleteToken;
@@ -959,6 +961,14 @@ function isDeclareVariable(node
   return node.type === 'DeclareVariable';
 }
 
+function isDecorator(node
+/*: ESNode | Token */
+)
+/*: implies node is Decorator */
+{
+  return node.type === 'Decorator';
+}
+
 function isDoWhileStatement(node
 /*: ESNode | Token */
 )

package/dist/generated/predicates.js.flow

@@ -82,6 +82,7 @@ import type {
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
+  Decorator,
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
@@ -494,6 +495,11 @@ export function isDeclareVariable(node /*: ESNode | Token */) /*: implies node i
 }
     
 
+export function isDecorator(node /*: ESNode | Token */) /*: implies node is Decorator */ {
+  return node.type === 'Decorator';
+}
+    
+
 export function isDoWhileStatement(node /*: ESNode | Token */) /*: implies node is DoWhileStatement */ {
   return node.type === 'DoWhileStatement';
 }

package/dist/src/generated/predicates.js

@@ -81,6 +81,7 @@ import type {
   DeclareOpaqueType,
   DeclareTypeAlias,
   DeclareVariable,
+  Decorator,
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
@@ -322,6 +323,7 @@ exports.isDeclareOpaqueType = isDeclareOpaqueType;
 exports.isDeclareTypeAlias = isDeclareTypeAlias;
 exports.isDeclareVariable = isDeclareVariable;
 exports.isDeclaredPredicate = isDeclaredPredicate;
+exports.isDecorator = isDecorator;
 exports.isDecrementToken = isDecrementToken;
 exports.isDefaultToken = isDefaultToken;
 exports.isDeleteToken = isDeleteToken;
@@ -959,6 +961,14 @@ function isDeclareVariable(node
   return node.type === 'DeclareVariable';
 }
 
+function isDecorator(node
+/*: ESNode | Token */
+)
+/*: implies node is Decorator */
+{
+  return node.type === 'Decorator';
+}
+
 function isDoWhileStatement(node
 /*: ESNode | Token */
 )

package/dist/types.js.flow

@@ -428,6 +428,7 @@ export interface ComponentParameter extends BaseNode {
 
 export interface ComponentDeclaration extends BaseNode {
   +type: 'ComponentDeclaration';
+  +async: boolean;
   +body: BlockStatement;
   +id: Identifier;
   +params: $ReadOnlyArray<ComponentParameterAndRestElement>;
@@ -437,6 +438,7 @@ export interface ComponentDeclaration extends BaseNode {
 
 export interface HookDeclaration extends BaseNode {
   +type: 'HookDeclaration';
+  +async: boolean;
   +id: Identifier;
   +body: BlockStatement;
   +params: $ReadOnlyArray<FunctionParameter>;
@@ -971,6 +973,7 @@ export interface MethodDefinitionConstructor extends MethodDefinitionBase {
   +kind: 'constructor';
   +computed: false;
   +static: false;
+  +decorators: $ReadOnlyArray<Decorator>;
 }
 export interface MethodDefinitionWithComputedName extends MethodDefinitionBase {
   +type: 'MethodDefinition';
@@ -978,6 +981,7 @@ export interface MethodDefinitionWithComputedName extends MethodDefinitionBase {
   +kind: 'method' | 'get' | 'set';
   +computed: true;
   +static: boolean;
+  +decorators: $ReadOnlyArray<Decorator>;
 }
 export interface MethodDefinitionWithNonComputedName
   extends MethodDefinitionBase {
@@ -986,6 +990,7 @@ export interface MethodDefinitionWithNonComputedName
   +kind: 'method' | 'get' | 'set';
   +computed: false;
   +static: boolean;
+  +decorators: $ReadOnlyArray<Decorator>;
 }
 
 // `PropertyDefinition` is the new standard for all class properties
@@ -996,6 +1001,7 @@ interface PropertyDefinitionBase extends BaseNode {
   +value: null | Expression;
   +typeAnnotation: null | TypeAnnotation;
   +static: boolean;
+  +decorators: $ReadOnlyArray<Decorator>;
   +variance: null | Variance;
   +declare: boolean;
   // hermes always emit this as false
@@ -1054,7 +1060,7 @@ export interface ImportDeclaration extends BaseNode {
     ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier,
   >;
   +source: StringLiteral;
-  +assertions: $ReadOnlyArray<ImportAttribute>;
+  +attributes: $ReadOnlyArray<ImportAttribute>;
 
   +importKind: 'value' | 'type' | 'typeof';
 }
@@ -1207,7 +1213,7 @@ export type TypeAnnotationType =
 
 export interface Variance extends BaseNode {
   +type: 'Variance';
-  +kind: 'plus' | 'minus';
+  +kind: 'plus' | 'minus' | 'readonly';
 }
 
 interface BaseTypeAlias extends BaseNode {

package/package.json

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