hermes-estree 0.7.0 → 0.8.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -32,12 +32,11 @@ import type {
   BreakStatement,
   CallExpression,
   CatchClause,
+  ChainExpression,
   ClassBody,
   ClassDeclaration,
   ClassExpression,
   ClassImplements,
-  ClassPrivateProperty,
-  ClassProperty,
   ConditionalExpression,
   ContinueStatement,
   DebuggerStatement,
@@ -68,7 +67,6 @@ import type {
   ExportAllDeclaration,
   ExportDefaultDeclaration,
   ExportNamedDeclaration,
-  ExportNamespaceSpecifier,
   ExportSpecifier,
   ExpressionStatement,
   ForInStatement,
@@ -128,12 +126,11 @@ import type {
   ObjectTypeProperty,
   ObjectTypeSpreadProperty,
   OpaqueType,
-  OptionalCallExpression,
   OptionalIndexedAccessType,
-  OptionalMemberExpression,
-  PrivateName,
+  PrivateIdentifier,
   Program,
   Property,
+  PropertyDefinition,
   QualifiedTypeIdentifier,
   RestElement,
   ReturnStatement,
@@ -276,6 +273,9 @@ interface CatchClause_With_param extends CatchClause {
 interface CatchClause_With_body extends CatchClause {
   +body: $NonMaybeType<CatchClause['body']>;
 }
+interface ChainExpression_With_expression extends ChainExpression {
+  +expression: $NonMaybeType<ChainExpression['expression']>;
+}
 interface ClassBody_With_body extends ClassBody {
   +body: $NonMaybeType<ClassBody['body']>;
 }
@@ -327,52 +327,6 @@ interface ClassImplements_With_id extends ClassImplements {
 interface ClassImplements_With_typeParameters extends ClassImplements {
   +typeParameters: $NonMaybeType<ClassImplements['typeParameters']>;
 }
-interface ClassPrivateProperty_With_key extends ClassPrivateProperty {
-  +key: $NonMaybeType<ClassPrivateProperty['key']>;
-}
-interface ClassPrivateProperty_With_value extends ClassPrivateProperty {
-  +value: $NonMaybeType<ClassPrivateProperty['value']>;
-}
-interface ClassPrivateProperty_With_static extends ClassPrivateProperty {
-  +static: $NonMaybeType<ClassPrivateProperty['static']>;
-}
-interface ClassPrivateProperty_With_declare extends ClassPrivateProperty {
-  +declare: $NonMaybeType<ClassPrivateProperty['declare']>;
-}
-interface ClassPrivateProperty_With_optional extends ClassPrivateProperty {
-  +optional: $NonMaybeType<ClassPrivateProperty['optional']>;
-}
-interface ClassPrivateProperty_With_variance extends ClassPrivateProperty {
-  +variance: $NonMaybeType<ClassPrivateProperty['variance']>;
-}
-interface ClassPrivateProperty_With_typeAnnotation
-  extends ClassPrivateProperty {
-  +typeAnnotation: $NonMaybeType<ClassPrivateProperty['typeAnnotation']>;
-}
-interface ClassProperty_With_key extends ClassProperty {
-  +key: $NonMaybeType<ClassProperty['key']>;
-}
-interface ClassProperty_With_value extends ClassProperty {
-  +value: $NonMaybeType<ClassProperty['value']>;
-}
-interface ClassProperty_With_computed extends ClassProperty {
-  +computed: $NonMaybeType<ClassProperty['computed']>;
-}
-interface ClassProperty_With_static extends ClassProperty {
-  +static: $NonMaybeType<ClassProperty['static']>;
-}
-interface ClassProperty_With_declare extends ClassProperty {
-  +declare: $NonMaybeType<ClassProperty['declare']>;
-}
-interface ClassProperty_With_optional extends ClassProperty {
-  +optional: $NonMaybeType<ClassProperty['optional']>;
-}
-interface ClassProperty_With_variance extends ClassProperty {
-  +variance: $NonMaybeType<ClassProperty['variance']>;
-}
-interface ClassProperty_With_typeAnnotation extends ClassProperty {
-  +typeAnnotation: $NonMaybeType<ClassProperty['typeAnnotation']>;
-}
 interface ConditionalExpression_With_test extends ConditionalExpression {
   +test: $NonMaybeType<ConditionalExpression['test']>;
 }
@@ -547,6 +501,9 @@ interface EnumSymbolBody_With_members extends EnumSymbolBody {
 interface EnumSymbolBody_With_hasUnknownMembers extends EnumSymbolBody {
   +hasUnknownMembers: $NonMaybeType<EnumSymbolBody['hasUnknownMembers']>;
 }
+interface ExportAllDeclaration_With_exported extends ExportAllDeclaration {
+  +exported: $NonMaybeType<ExportAllDeclaration['exported']>;
+}
 interface ExportAllDeclaration_With_source extends ExportAllDeclaration {
   +source: $NonMaybeType<ExportAllDeclaration['source']>;
 }
@@ -572,10 +529,6 @@ interface ExportNamedDeclaration_With_exportKind
   extends ExportNamedDeclaration {
   +exportKind: $NonMaybeType<ExportNamedDeclaration['exportKind']>;
 }
-interface ExportNamespaceSpecifier_With_exported
-  extends ExportNamespaceSpecifier {
-  +exported: $NonMaybeType<ExportNamespaceSpecifier['exported']>;
-}
 interface ExportSpecifier_With_exported extends ExportSpecifier {
   +exported: $NonMaybeType<ExportSpecifier['exported']>;
 }
@@ -1031,19 +984,6 @@ interface OpaqueType_With_impltype extends OpaqueType {
 interface OpaqueType_With_supertype extends OpaqueType {
   +supertype: $NonMaybeType<OpaqueType['supertype']>;
 }
-interface OptionalCallExpression_With_callee extends OptionalCallExpression {
-  +callee: $NonMaybeType<OptionalCallExpression['callee']>;
-}
-interface OptionalCallExpression_With_typeArguments
-  extends OptionalCallExpression {
-  +typeArguments: $NonMaybeType<OptionalCallExpression['typeArguments']>;
-}
-interface OptionalCallExpression_With_arguments extends OptionalCallExpression {
-  +arguments: $NonMaybeType<OptionalCallExpression['arguments']>;
-}
-interface OptionalCallExpression_With_optional extends OptionalCallExpression {
-  +optional: $NonMaybeType<OptionalCallExpression['optional']>;
-}
 interface OptionalIndexedAccessType_With_objectType
   extends OptionalIndexedAccessType {
   +objectType: $NonMaybeType<OptionalIndexedAccessType['objectType']>;
@@ -1056,24 +996,8 @@ interface OptionalIndexedAccessType_With_optional
   extends OptionalIndexedAccessType {
   +optional: $NonMaybeType<OptionalIndexedAccessType['optional']>;
 }
-interface OptionalMemberExpression_With_object
-  extends OptionalMemberExpression {
-  +object: $NonMaybeType<OptionalMemberExpression['object']>;
-}
-interface OptionalMemberExpression_With_property
-  extends OptionalMemberExpression {
-  +property: $NonMaybeType<OptionalMemberExpression['property']>;
-}
-interface OptionalMemberExpression_With_computed
-  extends OptionalMemberExpression {
-  +computed: $NonMaybeType<OptionalMemberExpression['computed']>;
-}
-interface OptionalMemberExpression_With_optional
-  extends OptionalMemberExpression {
-  +optional: $NonMaybeType<OptionalMemberExpression['optional']>;
-}
-interface PrivateName_With_id extends PrivateName {
-  +id: $NonMaybeType<PrivateName['id']>;
+interface PrivateIdentifier_With_name extends PrivateIdentifier {
+  +name: $NonMaybeType<PrivateIdentifier['name']>;
 }
 interface Program_With_body extends Program {
   +body: $NonMaybeType<Program['body']>;
@@ -1096,6 +1020,30 @@ interface Property_With_method extends Property {
 interface Property_With_shorthand extends Property {
   +shorthand: $NonMaybeType<Property['shorthand']>;
 }
+interface PropertyDefinition_With_key extends PropertyDefinition {
+  +key: $NonMaybeType<PropertyDefinition['key']>;
+}
+interface PropertyDefinition_With_value extends PropertyDefinition {
+  +value: $NonMaybeType<PropertyDefinition['value']>;
+}
+interface PropertyDefinition_With_computed extends PropertyDefinition {
+  +computed: $NonMaybeType<PropertyDefinition['computed']>;
+}
+interface PropertyDefinition_With_static extends PropertyDefinition {
+  +static: $NonMaybeType<PropertyDefinition['static']>;
+}
+interface PropertyDefinition_With_declare extends PropertyDefinition {
+  +declare: $NonMaybeType<PropertyDefinition['declare']>;
+}
+interface PropertyDefinition_With_optional extends PropertyDefinition {
+  +optional: $NonMaybeType<PropertyDefinition['optional']>;
+}
+interface PropertyDefinition_With_variance extends PropertyDefinition {
+  +variance: $NonMaybeType<PropertyDefinition['variance']>;
+}
+interface PropertyDefinition_With_typeAnnotation extends PropertyDefinition {
+  +typeAnnotation: $NonMaybeType<PropertyDefinition['typeAnnotation']>;
+}
 interface QualifiedTypeIdentifier_With_qualification
   extends QualifiedTypeIdentifier {
   +qualification: $NonMaybeType<QualifiedTypeIdentifier['qualification']>;
@@ -1309,6 +1257,7 @@ type ExpressionSpecialSelector =
   | AwaitExpression
   | BinaryExpression
   | CallExpression
+  | ChainExpression
   | ClassExpression
   | ConditionalExpression
   | FunctionExpression
@@ -1319,8 +1268,6 @@ type ExpressionSpecialSelector =
   | MemberExpression
   | NewExpression
   | ObjectExpression
-  | OptionalCallExpression
-  | OptionalMemberExpression
   | SequenceExpression
   | TaggedTemplateExpression
   | ThisExpression
@@ -1421,6 +1368,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +CatchClause?: (node: CatchClause) => void,
   +'CatchClause[param]'?: (node: CatchClause_With_param) => void,
   +'CatchClause[body]'?: (node: CatchClause_With_body) => void,
+  +ChainExpression?: (node: ChainExpression) => void,
+  +'ChainExpression[expression]'?: (
+    node: ChainExpression_With_expression,
+  ) => void,
   +ClassBody?: (node: ClassBody) => void,
   +'ClassBody[body]'?: (node: ClassBody_With_body) => void,
   +ClassDeclaration?: (node: ClassDeclaration) => void,
@@ -1464,37 +1415,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ClassImplements[typeParameters]'?: (
     node: ClassImplements_With_typeParameters,
   ) => void,
-  +ClassPrivateProperty?: (node: ClassPrivateProperty) => void,
-  +'ClassPrivateProperty[key]'?: (node: ClassPrivateProperty_With_key) => void,
-  +'ClassPrivateProperty[value]'?: (
-    node: ClassPrivateProperty_With_value,
-  ) => void,
-  +'ClassPrivateProperty[static]'?: (
-    node: ClassPrivateProperty_With_static,
-  ) => void,
-  +'ClassPrivateProperty[declare]'?: (
-    node: ClassPrivateProperty_With_declare,
-  ) => void,
-  +'ClassPrivateProperty[optional]'?: (
-    node: ClassPrivateProperty_With_optional,
-  ) => void,
-  +'ClassPrivateProperty[variance]'?: (
-    node: ClassPrivateProperty_With_variance,
-  ) => void,
-  +'ClassPrivateProperty[typeAnnotation]'?: (
-    node: ClassPrivateProperty_With_typeAnnotation,
-  ) => void,
-  +ClassProperty?: (node: ClassProperty) => void,
-  +'ClassProperty[key]'?: (node: ClassProperty_With_key) => void,
-  +'ClassProperty[value]'?: (node: ClassProperty_With_value) => void,
-  +'ClassProperty[computed]'?: (node: ClassProperty_With_computed) => void,
-  +'ClassProperty[static]'?: (node: ClassProperty_With_static) => void,
-  +'ClassProperty[declare]'?: (node: ClassProperty_With_declare) => void,
-  +'ClassProperty[optional]'?: (node: ClassProperty_With_optional) => void,
-  +'ClassProperty[variance]'?: (node: ClassProperty_With_variance) => void,
-  +'ClassProperty[typeAnnotation]'?: (
-    node: ClassProperty_With_typeAnnotation,
-  ) => void,
   +ConditionalExpression?: (node: ConditionalExpression) => void,
   +'ConditionalExpression[test]'?: (
     node: ConditionalExpression_With_test,
@@ -1625,6 +1545,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +ExistsTypeAnnotation?: (node: ExistsTypeAnnotation) => void,
   +ExportAllDeclaration?: (node: ExportAllDeclaration) => void,
+  +'ExportAllDeclaration[exported]'?: (
+    node: ExportAllDeclaration_With_exported,
+  ) => void,
   +'ExportAllDeclaration[source]'?: (
     node: ExportAllDeclaration_With_source,
   ) => void,
@@ -1648,10 +1571,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ExportNamedDeclaration[exportKind]'?: (
     node: ExportNamedDeclaration_With_exportKind,
   ) => void,
-  +ExportNamespaceSpecifier?: (node: ExportNamespaceSpecifier) => void,
-  +'ExportNamespaceSpecifier[exported]'?: (
-    node: ExportNamespaceSpecifier_With_exported,
-  ) => void,
   +ExportSpecifier?: (node: ExportSpecifier) => void,
   +'ExportSpecifier[exported]'?: (node: ExportSpecifier_With_exported) => void,
   +'ExportSpecifier[local]'?: (node: ExportSpecifier_With_local) => void,
@@ -2019,19 +1938,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'OpaqueType[impltype]'?: (node: OpaqueType_With_impltype) => void,
   +'OpaqueType[supertype]'?: (node: OpaqueType_With_supertype) => void,
-  +OptionalCallExpression?: (node: OptionalCallExpression) => void,
-  +'OptionalCallExpression[callee]'?: (
-    node: OptionalCallExpression_With_callee,
-  ) => void,
-  +'OptionalCallExpression[typeArguments]'?: (
-    node: OptionalCallExpression_With_typeArguments,
-  ) => void,
-  +'OptionalCallExpression[arguments]'?: (
-    node: OptionalCallExpression_With_arguments,
-  ) => void,
-  +'OptionalCallExpression[optional]'?: (
-    node: OptionalCallExpression_With_optional,
-  ) => void,
   +OptionalIndexedAccessType?: (node: OptionalIndexedAccessType) => void,
   +'OptionalIndexedAccessType[objectType]'?: (
     node: OptionalIndexedAccessType_With_objectType,
@@ -2042,21 +1948,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'OptionalIndexedAccessType[optional]'?: (
     node: OptionalIndexedAccessType_With_optional,
   ) => void,
-  +OptionalMemberExpression?: (node: OptionalMemberExpression) => void,
-  +'OptionalMemberExpression[object]'?: (
-    node: OptionalMemberExpression_With_object,
-  ) => void,
-  +'OptionalMemberExpression[property]'?: (
-    node: OptionalMemberExpression_With_property,
-  ) => void,
-  +'OptionalMemberExpression[computed]'?: (
-    node: OptionalMemberExpression_With_computed,
-  ) => void,
-  +'OptionalMemberExpression[optional]'?: (
-    node: OptionalMemberExpression_With_optional,
-  ) => void,
-  +PrivateName?: (node: PrivateName) => void,
-  +'PrivateName[id]'?: (node: PrivateName_With_id) => void,
+  +PrivateIdentifier?: (node: PrivateIdentifier) => void,
+  +'PrivateIdentifier[name]'?: (node: PrivateIdentifier_With_name) => void,
   +Program?: (node: Program) => void,
   +'Program[body]'?: (node: Program_With_body) => void,
   +Property?: (node: Property) => void,
@@ -2066,6 +1959,27 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'Property[computed]'?: (node: Property_With_computed) => void,
   +'Property[method]'?: (node: Property_With_method) => void,
   +'Property[shorthand]'?: (node: Property_With_shorthand) => void,
+  +PropertyDefinition?: (node: PropertyDefinition) => void,
+  +'PropertyDefinition[key]'?: (node: PropertyDefinition_With_key) => void,
+  +'PropertyDefinition[value]'?: (node: PropertyDefinition_With_value) => void,
+  +'PropertyDefinition[computed]'?: (
+    node: PropertyDefinition_With_computed,
+  ) => void,
+  +'PropertyDefinition[static]'?: (
+    node: PropertyDefinition_With_static,
+  ) => void,
+  +'PropertyDefinition[declare]'?: (
+    node: PropertyDefinition_With_declare,
+  ) => void,
+  +'PropertyDefinition[optional]'?: (
+    node: PropertyDefinition_With_optional,
+  ) => void,
+  +'PropertyDefinition[variance]'?: (
+    node: PropertyDefinition_With_variance,
+  ) => void,
+  +'PropertyDefinition[typeAnnotation]'?: (
+    node: PropertyDefinition_With_typeAnnotation,
+  ) => void,
   +QualifiedTypeIdentifier?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]'?: (
     node: QualifiedTypeIdentifier_With_qualification,
@@ -2302,6 +2216,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'CatchClause:exit'?: (node: CatchClause) => void,
   +'CatchClause[param]:exit'?: (node: CatchClause_With_param) => void,
   +'CatchClause[body]:exit'?: (node: CatchClause_With_body) => void,
+  +'ChainExpression:exit'?: (node: ChainExpression) => void,
+  +'ChainExpression[expression]:exit'?: (
+    node: ChainExpression_With_expression,
+  ) => void,
   +'ClassBody:exit'?: (node: ClassBody) => void,
   +'ClassBody[body]:exit'?: (node: ClassBody_With_body) => void,
   +'ClassDeclaration:exit'?: (node: ClassDeclaration) => void,
@@ -2345,39 +2263,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ClassImplements[typeParameters]:exit'?: (
     node: ClassImplements_With_typeParameters,
   ) => void,
-  +'ClassPrivateProperty:exit'?: (node: ClassPrivateProperty) => void,
-  +'ClassPrivateProperty[key]:exit'?: (
-    node: ClassPrivateProperty_With_key,
-  ) => void,
-  +'ClassPrivateProperty[value]:exit'?: (
-    node: ClassPrivateProperty_With_value,
-  ) => void,
-  +'ClassPrivateProperty[static]:exit'?: (
-    node: ClassPrivateProperty_With_static,
-  ) => void,
-  +'ClassPrivateProperty[declare]:exit'?: (
-    node: ClassPrivateProperty_With_declare,
-  ) => void,
-  +'ClassPrivateProperty[optional]:exit'?: (
-    node: ClassPrivateProperty_With_optional,
-  ) => void,
-  +'ClassPrivateProperty[variance]:exit'?: (
-    node: ClassPrivateProperty_With_variance,
-  ) => void,
-  +'ClassPrivateProperty[typeAnnotation]:exit'?: (
-    node: ClassPrivateProperty_With_typeAnnotation,
-  ) => void,
-  +'ClassProperty:exit'?: (node: ClassProperty) => void,
-  +'ClassProperty[key]:exit'?: (node: ClassProperty_With_key) => void,
-  +'ClassProperty[value]:exit'?: (node: ClassProperty_With_value) => void,
-  +'ClassProperty[computed]:exit'?: (node: ClassProperty_With_computed) => void,
-  +'ClassProperty[static]:exit'?: (node: ClassProperty_With_static) => void,
-  +'ClassProperty[declare]:exit'?: (node: ClassProperty_With_declare) => void,
-  +'ClassProperty[optional]:exit'?: (node: ClassProperty_With_optional) => void,
-  +'ClassProperty[variance]:exit'?: (node: ClassProperty_With_variance) => void,
-  +'ClassProperty[typeAnnotation]:exit'?: (
-    node: ClassProperty_With_typeAnnotation,
-  ) => void,
   +'ConditionalExpression:exit'?: (node: ConditionalExpression) => void,
   +'ConditionalExpression[test]:exit'?: (
     node: ConditionalExpression_With_test,
@@ -2520,6 +2405,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'ExistsTypeAnnotation:exit'?: (node: ExistsTypeAnnotation) => void,
   +'ExportAllDeclaration:exit'?: (node: ExportAllDeclaration) => void,
+  +'ExportAllDeclaration[exported]:exit'?: (
+    node: ExportAllDeclaration_With_exported,
+  ) => void,
   +'ExportAllDeclaration[source]:exit'?: (
     node: ExportAllDeclaration_With_source,
   ) => void,
@@ -2543,10 +2431,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ExportNamedDeclaration[exportKind]:exit'?: (
     node: ExportNamedDeclaration_With_exportKind,
   ) => void,
-  +'ExportNamespaceSpecifier:exit'?: (node: ExportNamespaceSpecifier) => void,
-  +'ExportNamespaceSpecifier[exported]:exit'?: (
-    node: ExportNamespaceSpecifier_With_exported,
-  ) => void,
   +'ExportSpecifier:exit'?: (node: ExportSpecifier) => void,
   +'ExportSpecifier[exported]:exit'?: (
     node: ExportSpecifier_With_exported,
@@ -2956,19 +2840,6 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'OpaqueType[impltype]:exit'?: (node: OpaqueType_With_impltype) => void,
   +'OpaqueType[supertype]:exit'?: (node: OpaqueType_With_supertype) => void,
-  +'OptionalCallExpression:exit'?: (node: OptionalCallExpression) => void,
-  +'OptionalCallExpression[callee]:exit'?: (
-    node: OptionalCallExpression_With_callee,
-  ) => void,
-  +'OptionalCallExpression[typeArguments]:exit'?: (
-    node: OptionalCallExpression_With_typeArguments,
-  ) => void,
-  +'OptionalCallExpression[arguments]:exit'?: (
-    node: OptionalCallExpression_With_arguments,
-  ) => void,
-  +'OptionalCallExpression[optional]:exit'?: (
-    node: OptionalCallExpression_With_optional,
-  ) => void,
   +'OptionalIndexedAccessType:exit'?: (node: OptionalIndexedAccessType) => void,
   +'OptionalIndexedAccessType[objectType]:exit'?: (
     node: OptionalIndexedAccessType_With_objectType,
@@ -2979,21 +2850,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'OptionalIndexedAccessType[optional]:exit'?: (
     node: OptionalIndexedAccessType_With_optional,
   ) => void,
-  +'OptionalMemberExpression:exit'?: (node: OptionalMemberExpression) => void,
-  +'OptionalMemberExpression[object]:exit'?: (
-    node: OptionalMemberExpression_With_object,
-  ) => void,
-  +'OptionalMemberExpression[property]:exit'?: (
-    node: OptionalMemberExpression_With_property,
-  ) => void,
-  +'OptionalMemberExpression[computed]:exit'?: (
-    node: OptionalMemberExpression_With_computed,
-  ) => void,
-  +'OptionalMemberExpression[optional]:exit'?: (
-    node: OptionalMemberExpression_With_optional,
-  ) => void,
-  +'PrivateName:exit'?: (node: PrivateName) => void,
-  +'PrivateName[id]:exit'?: (node: PrivateName_With_id) => void,
+  +'PrivateIdentifier:exit'?: (node: PrivateIdentifier) => void,
+  +'PrivateIdentifier[name]:exit'?: (node: PrivateIdentifier_With_name) => void,
   +'Program:exit'?: (node: Program) => void,
   +'Program[body]:exit'?: (node: Program_With_body) => void,
   +'Property:exit'?: (node: Property) => void,
@@ -3003,6 +2861,29 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'Property[computed]:exit'?: (node: Property_With_computed) => void,
   +'Property[method]:exit'?: (node: Property_With_method) => void,
   +'Property[shorthand]:exit'?: (node: Property_With_shorthand) => void,
+  +'PropertyDefinition:exit'?: (node: PropertyDefinition) => void,
+  +'PropertyDefinition[key]:exit'?: (node: PropertyDefinition_With_key) => void,
+  +'PropertyDefinition[value]:exit'?: (
+    node: PropertyDefinition_With_value,
+  ) => void,
+  +'PropertyDefinition[computed]:exit'?: (
+    node: PropertyDefinition_With_computed,
+  ) => void,
+  +'PropertyDefinition[static]:exit'?: (
+    node: PropertyDefinition_With_static,
+  ) => void,
+  +'PropertyDefinition[declare]:exit'?: (
+    node: PropertyDefinition_With_declare,
+  ) => void,
+  +'PropertyDefinition[optional]:exit'?: (
+    node: PropertyDefinition_With_optional,
+  ) => void,
+  +'PropertyDefinition[variance]:exit'?: (
+    node: PropertyDefinition_With_variance,
+  ) => void,
+  +'PropertyDefinition[typeAnnotation]:exit'?: (
+    node: PropertyDefinition_With_typeAnnotation,
+  ) => void,
   +'QualifiedTypeIdentifier:exit'?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]:exit'?: (
     node: QualifiedTypeIdentifier_With_qualification,

package/dist/generated/predicates.js

@@ -53,12 +53,11 @@ exports.isCallExpression = isCallExpression;
 exports.isCaseToken = isCaseToken;
 exports.isCatchClause = isCatchClause;
 exports.isCatchToken = isCatchToken;
+exports.isChainExpression = isChainExpression;
 exports.isClassBody = isClassBody;
 exports.isClassDeclaration = isClassDeclaration;
 exports.isClassExpression = isClassExpression;
 exports.isClassImplements = isClassImplements;
-exports.isClassPrivateProperty = isClassPrivateProperty;
-exports.isClassProperty = isClassProperty;
 exports.isClassToken = isClassToken;
 exports.isClosingAngleBracketToken = isClosingAngleBracketToken;
 exports.isClosingCurlyBracketToken = isClosingCurlyBracketToken;
@@ -111,7 +110,6 @@ exports.isExponentiationToken = isExponentiationToken;
 exports.isExportAllDeclaration = isExportAllDeclaration;
 exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
 exports.isExportNamedDeclaration = isExportNamedDeclaration;
-exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
 exports.isExportSpecifier = isExportSpecifier;
 exports.isExportToken = isExportToken;
 exports.isExpressionStatement = isExpressionStatement;
@@ -212,15 +210,14 @@ exports.isOpaqueType = isOpaqueType;
 exports.isOpeningAngleBracketToken = isOpeningAngleBracketToken;
 exports.isOpeningCurlyBracketToken = isOpeningCurlyBracketToken;
 exports.isOpeningParenthesisToken = isOpeningParenthesisToken;
-exports.isOptionalCallExpression = isOptionalCallExpression;
 exports.isOptionalChainToken = isOptionalChainToken;
 exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
-exports.isOptionalMemberExpression = isOptionalMemberExpression;
 exports.isPercentToken = isPercentToken;
 exports.isPlusEqualToken = isPlusEqualToken;
 exports.isPlusToken = isPlusToken;
-exports.isPrivateName = isPrivateName;
+exports.isPrivateIdentifier = isPrivateIdentifier;
 exports.isProperty = isProperty;
+exports.isPropertyDefinition = isPropertyDefinition;
 exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
 exports.isQuestionMarkToken = isQuestionMarkToken;
 exports.isRemainderEqualToken = isRemainderEqualToken;
@@ -344,6 +341,10 @@ function isCatchClause(node) {
   return node.type === 'CatchClause';
 }
 
+function isChainExpression(node) {
+  return node.type === 'ChainExpression';
+}
+
 function isClassBody(node) {
   return node.type === 'ClassBody';
 }
@@ -360,14 +361,6 @@ function isClassImplements(node) {
   return node.type === 'ClassImplements';
 }
 
-function isClassPrivateProperty(node) {
-  return node.type === 'ClassPrivateProperty';
-}
-
-function isClassProperty(node) {
-  return node.type === 'ClassProperty';
-}
-
 function isConditionalExpression(node) {
   return node.type === 'ConditionalExpression';
 }
@@ -488,10 +481,6 @@ function isExportNamedDeclaration(node) {
   return node.type === 'ExportNamedDeclaration';
 }
 
-function isExportNamespaceSpecifier(node) {
-  return node.type === 'ExportNamespaceSpecifier';
-}
-
 function isExportSpecifier(node) {
   return node.type === 'ExportSpecifier';
 }
@@ -728,26 +717,22 @@ function isOpaqueType(node) {
   return node.type === 'OpaqueType';
 }
 
-function isOptionalCallExpression(node) {
-  return node.type === 'OptionalCallExpression';
-}
-
 function isOptionalIndexedAccessType(node) {
   return node.type === 'OptionalIndexedAccessType';
 }
 
-function isOptionalMemberExpression(node) {
-  return node.type === 'OptionalMemberExpression';
-}
-
-function isPrivateName(node) {
-  return node.type === 'PrivateName';
+function isPrivateIdentifier(node) {
+  return node.type === 'PrivateIdentifier';
 }
 
 function isProperty(node) {
   return node.type === 'Property';
 }
 
+function isPropertyDefinition(node) {
+  return node.type === 'PropertyDefinition';
+}
+
 function isQualifiedTypeIdentifier(node) {
   return node.type === 'QualifiedTypeIdentifier';
 }

package/dist/generated/predicates.js.flow

@@ -86,6 +86,10 @@ export function isCatchClause(node: ESNode | Token): boolean %checks {
   return node.type === 'CatchClause';
 }
 
+export function isChainExpression(node: ESNode | Token): boolean %checks {
+  return node.type === 'ChainExpression';
+}
+
 export function isClassBody(node: ESNode | Token): boolean %checks {
   return node.type === 'ClassBody';
 }
@@ -102,14 +106,6 @@ export function isClassImplements(node: ESNode | Token): boolean %checks {
   return node.type === 'ClassImplements';
 }
 
-export function isClassPrivateProperty(node: ESNode | Token): boolean %checks {
-  return node.type === 'ClassPrivateProperty';
-}
-
-export function isClassProperty(node: ESNode | Token): boolean %checks {
-  return node.type === 'ClassProperty';
-}
-
 export function isConditionalExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'ConditionalExpression';
 }
@@ -238,12 +234,6 @@ export function isExportNamedDeclaration(
   return node.type === 'ExportNamedDeclaration';
 }
 
-export function isExportNamespaceSpecifier(
-  node: ESNode | Token,
-): boolean %checks {
-  return node.type === 'ExportNamespaceSpecifier';
-}
-
 export function isExportSpecifier(node: ESNode | Token): boolean %checks {
   return node.type === 'ExportSpecifier';
 }
@@ -504,32 +494,24 @@ export function isOpaqueType(node: ESNode | Token): boolean %checks {
   return node.type === 'OpaqueType';
 }
 
-export function isOptionalCallExpression(
-  node: ESNode | Token,
-): boolean %checks {
-  return node.type === 'OptionalCallExpression';
-}
-
 export function isOptionalIndexedAccessType(
   node: ESNode | Token,
 ): boolean %checks {
   return node.type === 'OptionalIndexedAccessType';
 }
 
-export function isOptionalMemberExpression(
-  node: ESNode | Token,
-): boolean %checks {
-  return node.type === 'OptionalMemberExpression';
-}
-
-export function isPrivateName(node: ESNode | Token): boolean %checks {
-  return node.type === 'PrivateName';
+export function isPrivateIdentifier(node: ESNode | Token): boolean %checks {
+  return node.type === 'PrivateIdentifier';
 }
 
 export function isProperty(node: ESNode | Token): boolean %checks {
   return node.type === 'Property';
 }
 
+export function isPropertyDefinition(node: ESNode | Token): boolean %checks {
+  return node.type === 'PropertyDefinition';
+}
+
 export function isQualifiedTypeIdentifier(
   node: ESNode | Token,
 ): boolean %checks {

package/dist/predicates.js

@@ -14,7 +14,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 var _exportNames = {
   isClass: true,
-  isClassPropertyWithNonComputedName: true,
+  isPropertyDefinitionWithNonComputedName: true,
   isClassMember: true,
   isClassMemberWithNonComputedName: true,
   isComment: true,
@@ -36,7 +36,6 @@ exports.isBooleanLiteral = isBooleanLiteral;
 exports.isClass = isClass;
 exports.isClassMember = isClassMember;
 exports.isClassMemberWithNonComputedName = isClassMemberWithNonComputedName;
-exports.isClassPropertyWithNonComputedName = isClassPropertyWithNonComputedName;
 exports.isComment = isComment;
 exports.isFunction = isFunction;
 exports.isMemberExpressionWithNonComputedProperty = isMemberExpressionWithNonComputedProperty;
@@ -46,6 +45,7 @@ exports.isNumericLiteral = isNumericLiteral;
 exports.isObjectPropertyWithNonComputedName = isObjectPropertyWithNonComputedName;
 exports.isObjectPropertyWithShorthand = isObjectPropertyWithShorthand;
 exports.isOptionalMemberExpressionWithNonComputedProperty = isOptionalMemberExpressionWithNonComputedProperty;
+exports.isPropertyDefinitionWithNonComputedName = isPropertyDefinitionWithNonComputedName;
 exports.isRegExpLiteral = isRegExpLiteral;
 exports.isStringLiteral = isStringLiteral;
 
@@ -62,12 +62,12 @@ function isClass(node) {
   return (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isClassExpression)(node);
 }
 
-function isClassPropertyWithNonComputedName(node) {
-  return (0, _predicates.isClassProperty)(node) && node.computed === false;
+function isPropertyDefinitionWithNonComputedName(node) {
+  return (0, _predicates.isPropertyDefinition)(node) && node.computed === false;
 }
 
 function isClassMember(node) {
-  return (0, _predicates.isClassProperty)(node) || (0, _predicates.isClassPrivateProperty)(node) || (0, _predicates.isMethodDefinition)(node);
+  return (0, _predicates.isPropertyDefinition)(node) || (0, _predicates.isMethodDefinition)(node);
 }
 
 function isClassMemberWithNonComputedName(node) {

package/dist/predicates.js.flow

@@ -17,14 +17,13 @@ import {
   isBlockComment,
   isClassDeclaration,
   isClassExpression,
-  isClassPrivateProperty,
-  isClassProperty,
   isFunctionDeclaration,
   isFunctionExpression,
   isLineComment,
   isLiteral,
   isMemberExpression,
   isMethodDefinition,
+  isPropertyDefinition,
   isProperty,
 } from './generated/predicates';
 
@@ -34,18 +33,14 @@ export function isClass(node: ESNode): boolean %checks {
   return isClassDeclaration(node) || isClassExpression(node);
 }
 
-export function isClassPropertyWithNonComputedName(
+export function isPropertyDefinitionWithNonComputedName(
   node: ESNode,
 ): boolean %checks {
-  return isClassProperty(node) && node.computed === false;
+  return isPropertyDefinition(node) && node.computed === false;
 }
 
 export function isClassMember(node: ESNode): boolean %checks {
-  return (
-    isClassProperty(node) ||
-    isClassPrivateProperty(node) ||
-    isMethodDefinition(node)
-  );
+  return isPropertyDefinition(node) || isMethodDefinition(node);
 }
 
 export function isClassMemberWithNonComputedName(

package/dist/types.js.flow

@@ -105,6 +105,26 @@ export interface Position {
   +column: number;
 }
 
+// note: this is only ever present on Program.interpreter, never in the body
+interface InterpreterDirective extends BaseNode {
+  type: 'InterpreterDirective';
+  value: string;
+}
+
+export type DocblockDirectives = $ReadOnly<{
+  // some well-known tags
+  flow?: $ReadOnlyArray<string> | void,
+  format?: $ReadOnlyArray<string> | void,
+  noflow?: $ReadOnlyArray<string> | void,
+  noformat?: $ReadOnlyArray<string> | void,
+  [string]: $ReadOnlyArray<string> | void,
+}>;
+
+export type DocblockMetadata = $ReadOnly<{
+  directives: DocblockDirectives,
+  comment: BlockComment,
+}>;
+
 export interface Program extends BaseNode {
   +type: 'Program';
   +sourceType: 'script' | 'module';
@@ -112,6 +132,8 @@ export interface Program extends BaseNode {
   +tokens: $ReadOnlyArray<Token>;
   +comments: $ReadOnlyArray<Comment>;
   +loc: SourceLocation;
+  +interpreter: null | InterpreterDirective;
+  +docblock: null | DocblockMetadata;
   // program is the only node without a parent - but typing it as such is _super_ annoying and difficult
   +parent: ESNode;
 }
@@ -120,6 +142,7 @@ export interface Program extends BaseNode {
 // Because this file declares global types - we can't clash with it
 export type ESNode =
   | Identifier
+  | PrivateIdentifier
   | Literal
   | Program
   | AFunction
@@ -139,6 +162,7 @@ export type ESNode =
   | ClassBody
   | AClass
   | MethodDefinition
+  | PropertyDefinition
   | ModuleDeclaration
   | ModuleSpecifier
   | ImportAttribute
@@ -153,9 +177,6 @@ export type ESNode =
   | ObjectTypeIndexer
   | ObjectTypeSpreadProperty
   | InterfaceExtends
-  | ClassProperty
-  | ClassPrivateProperty
-  | PrivateName
   | ClassImplements
   | Decorator
   | TypeParameterDeclaration
@@ -221,7 +242,9 @@ export type Statement =
   | TypeAlias
   | OpaqueType
   | InterfaceDeclaration
-  | Declaration
+  | FunctionDeclaration
+  | VariableDeclaration
+  | ClassDeclaration
   | DeclareTypeAlias
   | DeclareOpaqueType
   | DeclareInterface
@@ -347,11 +370,6 @@ export interface DebuggerStatement extends BaseNode {
   +type: 'DebuggerStatement';
 }
 
-export type Declaration =
-  | FunctionDeclaration
-  | VariableDeclaration
-  | ClassDeclaration;
-
 export interface FunctionDeclaration extends BaseFunction {
   +type: 'FunctionDeclaration';
   /** It is null when a function declaration is a part of the `export default function` statement */
@@ -386,10 +404,8 @@ export type Expression =
   | AssignmentExpression
   | LogicalExpression
   | MemberExpression
-  | OptionalMemberExpression
   | ConditionalExpression
   | CallExpression
-  | OptionalCallExpression
   | NewExpression
   | SequenceExpression
   | TemplateLiteral
@@ -522,15 +538,24 @@ export interface UnaryExpression extends BaseNode {
   +argument: Expression;
 }
 
-export interface BinaryExpression extends BaseNode {
+export interface BinaryExpressionWithoutIn extends BaseNode {
   +type: 'BinaryExpression';
-  +operator: BinaryOperator;
+  +operator: BinaryOperatorWithoutIn;
   +left: Expression;
   +right: Expression;
-  // once private brand checks are supported: `#x in this`
-  // | PrivateName;
 }
 
+// Private brand checks (#foo in bar) are a special case
+// other binary expressions do not allow PrivateIdentifier in the left
+export interface BinaryExpressionIn extends BaseNode {
+  +type: 'BinaryExpression';
+  +operator: 'in';
+  +left: Expression | PrivateIdentifier;
+  +right: Expression;
+}
+
+export type BinaryExpression = BinaryExpressionWithoutIn | BinaryExpressionIn;
+
 export interface AssignmentExpression extends BaseNode {
   +type: 'AssignmentExpression';
   +operator: AssignmentOperator;
@@ -566,34 +591,31 @@ interface BaseCallExpression extends BaseNode {
 }
 export interface CallExpression extends BaseCallExpression {
   +type: 'CallExpression';
+  +optional: boolean;
 }
 
 export interface NewExpression extends BaseCallExpression {
   +type: 'NewExpression';
 }
 
-interface BaseMemberExpressionWithComputedName extends BaseNode {
-  +object: Expression | Super;
-  +property: Expression;
-  +computed: true;
-}
-interface BaseMemberExpressionWithNonComputedName extends BaseNode {
-  +object: Expression | Super;
-  +property: Identifier | PrivateName;
-  +computed: false;
-}
 export type MemberExpression =
   | MemberExpressionWithComputedName
   | MemberExpressionWithNonComputedName;
-export interface MemberExpressionWithComputedName
-  extends BaseMemberExpressionWithComputedName {
+export interface MemberExpressionWithComputedName extends BaseNode {
   +type: 'MemberExpression';
   +computed: true;
+  +object: Expression | Super;
+  +property: Expression;
+  +computed: true;
+  +optional: boolean;
 }
-export interface MemberExpressionWithNonComputedName
-  extends BaseMemberExpressionWithNonComputedName {
+export interface MemberExpressionWithNonComputedName extends BaseNode {
   +type: 'MemberExpression';
   +computed: false;
+  +object: Expression | Super;
+  +property: Identifier | PrivateIdentifier;
+  +computed: false;
+  +optional: boolean;
 }
 
 export type ChainElement = CallExpression | MemberExpression;
@@ -624,6 +646,11 @@ export interface Identifier extends BaseNode {
   +optional: boolean;
 }
 
+export interface PrivateIdentifier extends BaseNode {
+  +type: 'PrivateIdentifier';
+  +name: string;
+}
+
 export type Literal =
   | BigIntLiteral
   | BooleanLiteral
@@ -688,7 +715,7 @@ export type UnaryOperator =
   | 'void'
   | 'delete';
 
-export type BinaryOperator =
+export type BinaryOperatorWithoutIn =
   | '=='
   | '!='
   | '==='
@@ -709,9 +736,10 @@ export type BinaryOperator =
   | '|'
   | '^'
   | '&'
-  | 'in'
   | 'instanceof';
 
+export type BinaryOperator = BinaryOperatorWithoutIn | 'in';
+
 export type LogicalOperator = '||' | '&&' | '??';
 
 export type AssignmentOperator =
@@ -817,13 +845,18 @@ interface BaseClass extends BaseNode {
   +decorators: $ReadOnlyArray<Decorator>;
 }
 
-export type ClassMember =
-  | ClassProperty
-  | ClassPrivateProperty
-  | MethodDefinition;
+export type PropertyName =
+  | ClassPropertyNameComputed
+  | ClassPropertyNameNonComputed;
+export type ClassPropertyNameComputed = Expression;
+export type ClassPropertyNameNonComputed =
+  | PrivateIdentifier
+  | Identifier
+  | StringLiteral;
+
+export type ClassMember = PropertyDefinition | MethodDefinition;
 export type ClassMemberWithNonComputedName =
-  | ClassPropertyWithNonComputedName
-  | ClassPrivateProperty
+  | PropertyDefinitionWithNonComputedName
   | MethodDefinitionConstructor
   | MethodDefinitionWithNonComputedName;
 export interface ClassBody extends BaseNode {
@@ -847,7 +880,7 @@ export interface MethodDefinitionConstructor extends MethodDefinitionBase {
 }
 export interface MethodDefinitionWithComputedName extends MethodDefinitionBase {
   +type: 'MethodDefinition';
-  +key: Expression;
+  +key: ClassPropertyNameComputed;
   +kind: 'method' | 'get' | 'set';
   +computed: true;
   +static: boolean;
@@ -855,12 +888,38 @@ export interface MethodDefinitionWithComputedName extends MethodDefinitionBase {
 export interface MethodDefinitionWithNonComputedName
   extends MethodDefinitionBase {
   +type: 'MethodDefinition';
-  +key: Identifier;
+  +key: ClassPropertyNameNonComputed;
   +kind: 'method' | 'get' | 'set';
   +computed: false;
   +static: boolean;
 }
 
+// `PropertyDefinition` is the new standard for all class properties
+export type PropertyDefinition =
+  | PropertyDefinitionWithComputedName
+  | PropertyDefinitionWithNonComputedName;
+interface PropertyDefinitionBase extends BaseNode {
+  +value: null | Expression;
+  +typeAnnotation: null | TypeAnnotation;
+  +static: boolean;
+  +variance: null | Variance;
+  +declare: boolean;
+  // hermes always emit this as false
+  +optional: false;
+}
+export interface PropertyDefinitionWithComputedName
+  extends PropertyDefinitionBase {
+  +type: 'PropertyDefinition';
+  +key: ClassPropertyNameComputed;
+  +computed: true;
+}
+export interface PropertyDefinitionWithNonComputedName
+  extends PropertyDefinitionBase {
+  +type: 'PropertyDefinition';
+  +key: ClassPropertyNameNonComputed;
+  +computed: false;
+}
+
 export interface ClassDeclaration extends BaseClass {
   +type: 'ClassDeclaration';
   /** It is null when a class declaration is a part of the `export default class` statement */
@@ -891,8 +950,7 @@ export type ModuleSpecifier =
   | ImportSpecifier
   | ImportDefaultSpecifier
   | ImportNamespaceSpecifier
-  | ExportSpecifier
-  | ExportNamespaceSpecifier;
+  | ExportSpecifier;
 
 export interface ImportDeclaration extends BaseNode {
   +type: 'ImportDeclaration';
@@ -933,10 +991,19 @@ export interface ImportNamespaceSpecifier extends BaseNode {
   +local: Identifier;
 }
 
+export type DefaultDeclaration = FunctionDeclaration | ClassDeclaration;
+export type NamedDeclaration =
+  | DefaultDeclaration
+  | VariableDeclaration
+  | TypeAlias
+  | OpaqueType
+  | InterfaceDeclaration
+  | EnumDeclaration;
+
 export interface ExportNamedDeclaration extends BaseNode {
   +type: 'ExportNamedDeclaration';
-  +declaration?: Declaration | null;
-  +specifiers: $ReadOnlyArray<ExportSpecifier | ExportNamespaceSpecifier>;
+  +declaration?: NamedDeclaration | null;
+  +specifiers: $ReadOnlyArray<ExportSpecifier>;
   +source?: Literal | null;
   +exportKind: 'value' | 'type';
 }
@@ -949,15 +1016,14 @@ export interface ExportSpecifier extends BaseNode {
 
 export interface ExportDefaultDeclaration extends BaseNode {
   +type: 'ExportDefaultDeclaration';
-  +declaration: Declaration | Expression;
+  +declaration: DefaultDeclaration | Expression;
 }
 
 export interface ExportAllDeclaration extends BaseNode {
   +type: 'ExportAllDeclaration';
   +source: Literal;
   +exportKind: 'value' | 'type';
-  // uncomment this when hermes stops using ExportNamespaceSpecifier
-  // +exported: Identifier;
+  +exported?: Identifier | null;
 }
 
 export interface AwaitExpression extends BaseNode {
@@ -1379,7 +1445,7 @@ export interface DeclareExportDeclaration extends BaseNode {
   +type: 'DeclareExportDeclaration';
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
   +declaration:
-    | TypeAnnotationType
+    | TypeAlias
     | DeclareClass
     | DeclareFunction
     | DeclareOpaqueType
@@ -1518,67 +1584,4 @@ export interface JSXSpreadChild extends BaseNode {
  * Deprecated spec nodes awaiting migration by Hermes *
  ******************************************************/
 
-// `ChainExpression` is the new standard for optional chaining
-export interface OptionalCallExpression extends BaseCallExpression {
-  +type: 'OptionalCallExpression';
-  +optional: boolean;
-}
-export type OptionalMemberExpression =
-  | OptionalMemberExpressionWithComputedName
-  | OptionalMemberExpressionWithNonComputedName;
-export interface OptionalMemberExpressionWithComputedName
-  extends BaseMemberExpressionWithComputedName {
-  +type: 'OptionalMemberExpression';
-  +optional: boolean;
-  +computed: true;
-}
-export interface OptionalMemberExpressionWithNonComputedName
-  extends BaseMemberExpressionWithNonComputedName {
-  +type: 'OptionalMemberExpression';
-  +optional: boolean;
-  +computed: false;
-}
-
-// `ExportAllDeclaration` is the new standard for `export * as y from 'z'`
-export interface ExportNamespaceSpecifier extends BaseNode {
-  +type: 'ExportNamespaceSpecifier';
-  +exported: Identifier;
-}
-
-// `PropertyDefinition` is the new standard for all class properties
-export type ClassProperty =
-  | ClassPropertyWithComputedName
-  | ClassPropertyWithNonComputedName;
-interface ClassPropertyBase extends BaseNode {
-  +value: null | Expression;
-  +typeAnnotation: null | TypeAnnotationType;
-  +static: boolean;
-  +variance: null | Variance;
-  +declare: boolean;
-  // hermes always emit this as false
-  +optional: false;
-}
-export interface ClassPropertyWithComputedName extends ClassPropertyBase {
-  +type: 'ClassProperty';
-  +key: Expression;
-  +computed: true;
-}
-export interface ClassPropertyWithNonComputedName extends ClassPropertyBase {
-  +type: 'ClassProperty';
-  +key: Identifier;
-  +computed: false;
-}
-export interface ClassPrivateProperty extends ClassPropertyBase {
-  +type: 'ClassPrivateProperty';
-  +key: Identifier;
-  // this is never emitted, but it makes it easier to do lookups with the `ClassMember` type
-  +computed?: void;
-}
-
-// `PrivateIdentifier` is the new standard for #private identifiers
-export interface PrivateName extends BaseNode {
-  +type: 'PrivateName';
-  +id: Identifier;
-}
-
 export {};

package/package.json

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