hermes-estree 0.5.0 → 0.8.0

package/dist/types.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -64,6 +64,7 @@ export interface MostTokens extends BaseToken {
     | 'Keyword'
     | 'Null'
     | 'Numeric'
+    | 'BigInt'
     | 'Punctuator'
     | 'RegularExpression'
     | 'String'
@@ -104,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';
@@ -111,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;
 }
@@ -119,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
@@ -131,10 +155,14 @@ export type ESNode =
   | Super
   | TemplateElement
   | SpreadElement
-  | Pattern
+  | BindingName
+  | RestElement
+  | AssignmentPattern
+  | MemberExpression
   | ClassBody
   | AClass
   | MethodDefinition
+  | PropertyDefinition
   | ModuleDeclaration
   | ModuleSpecifier
   | ImportAttribute
@@ -149,8 +177,6 @@ export type ESNode =
   | ObjectTypeIndexer
   | ObjectTypeSpreadProperty
   | InterfaceExtends
-  | ClassProperty
-  | ClassPrivateProperty
   | ClassImplements
   | Decorator
   | TypeParameterDeclaration
@@ -165,17 +191,23 @@ export type ESNode =
   | EnumBooleanBody
   | EnumBooleanMember
   | EnumSymbolBody
-  | DeclareClass
-  | DeclareVariable
-  | DeclareFunction
-  | DeclaredPredicate
-  | DeclareModule
+  | DeclaredNode
   | ObjectTypeInternalSlot
   // JSX
   | JSXNode;
 
+export type BindingName = Identifier | BindingPattern;
+export type BindingPattern = ArrayPattern | ObjectPattern;
+export type RestElementPattern = AssignmentPattern | BindingName | RestElement;
+export type FunctionParameter = AssignmentPattern | BindingName | RestElement;
+export type DestructuringPattern =
+  | BindingName
+  | AssignmentPattern
+  | MemberExpression
+  | RestElement;
+
 interface BaseFunction extends BaseNode {
-  +params: $ReadOnlyArray<Pattern>;
+  +params: $ReadOnlyArray<FunctionParameter>;
   +async: boolean;
 
   +predicate: null | InferredPredicate;
@@ -210,7 +242,9 @@ export type Statement =
   | TypeAlias
   | OpaqueType
   | InterfaceDeclaration
-  | Declaration
+  | FunctionDeclaration
+  | VariableDeclaration
+  | ClassDeclaration
   | DeclareTypeAlias
   | DeclareOpaqueType
   | DeclareInterface
@@ -318,7 +352,7 @@ export interface ForStatement extends BaseNode {
 }
 
 interface BaseForXStatement extends BaseNode {
-  +left: VariableDeclaration | Pattern;
+  +left: VariableDeclaration | BindingName | MemberExpression;
   +right: Expression;
   +body: Statement;
 }
@@ -336,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 */
@@ -357,7 +386,7 @@ export interface VariableDeclaration extends BaseNode {
 
 export interface VariableDeclarator extends BaseNode {
   +type: 'VariableDeclarator';
-  +id: Pattern;
+  +id: BindingName;
   +init?: Expression | null;
 }
 
@@ -375,10 +404,8 @@ export type Expression =
   | AssignmentExpression
   | LogicalExpression
   | MemberExpression
-  | OptionalMemberExpression
   | ConditionalExpression
   | CallExpression
-  | OptionalCallExpression
   | NewExpression
   | SequenceExpression
   | TemplateLiteral
@@ -390,7 +417,8 @@ export type Expression =
   | ImportExpression
   | ChainExpression
   | TypeCastExpression
-  | PrivateName;
+  | JSXFragment
+  | JSXElement;
 
 export interface ThisExpression extends BaseNode {
   +type: 'ThisExpression';
@@ -405,30 +433,91 @@ export interface ArrayExpression extends BaseNode {
 
 export interface ObjectExpression extends BaseNode {
   +type: 'ObjectExpression';
-  +properties: $ReadOnlyArray<Property | SpreadElement>;
+  +properties: $ReadOnlyArray<ObjectProperty | SpreadElement>;
 }
 
-interface PropertyBase extends BaseNode {
-  +key: Expression;
-  +shorthand: boolean;
-  +computed: boolean;
-}
+// This is the complete type of a "Property"
+// This same node (unfortunately) covers both object literal properties
+// and object desturcturing properties.
+export type Property = ObjectProperty | DestructuringObjectProperty;
 
-export interface Property extends PropertyBase {
+export type ObjectProperty =
+  | ObjectPropertyWithNonShorthandStaticName
+  | ObjectPropertyWithShorthandStaticName
+  | ObjectPropertyWithComputedName;
+export interface ObjectPropertyWithNonShorthandStaticName extends BaseNode {
   +type: 'Property';
-  +value: Expression | Pattern; // Could be an AssignmentProperty
+  +computed: false;
+  // non-computed, non-shorthand names are constrained significantly
+  +key: Identifier | StringLiteral | NumericLiteral;
+  +value: Expression;
   +kind: 'init' | 'get' | 'set';
   +method: boolean;
+  +shorthand: false;
 }
-
-// this is a special type of property
-// we can't use `interface ... extends` here because it's a sub-type
-export interface AssignmentProperty extends PropertyBase {
+export interface ObjectPropertyWithShorthandStaticName extends BaseNode {
   +type: 'Property';
-  +value: Pattern;
+  +computed: false;
+  // shorthand keys *must* be identifiers
+  +key: Identifier;
+  // shorthand values *must* be identifiers (that look the same as the key)
+  +value: Identifier;
+  +kind: 'init';
+  +method: boolean;
+  +shorthand: true;
+}
+export interface ObjectPropertyWithComputedName extends BaseNode {
+  +type: 'Property';
+  +computed: true;
+  // computed names can be any expression
+  +key: Expression;
+  +value: Expression;
+  +kind: 'init' | 'get' | 'set';
+  +method: boolean;
+  // cannot have a shorthand computed name
+  +shorthand: false;
+}
+
+export type DestructuringObjectProperty =
+  | DestructuringObjectPropertyWithNonShorthandStaticName
+  | DestructuringObjectPropertyWithShorthandStaticName
+  | DestructuringObjectPropertyWithComputedName;
+interface DestructuringObjectPropertyBase extends BaseNode {
+  // destructuring properties cannot be methods
   +kind: 'init';
   +method: false;
 }
+export interface DestructuringObjectPropertyWithNonShorthandStaticName
+  extends DestructuringObjectPropertyBase {
+  +type: 'Property';
+  +computed: false;
+  // non-computed, non-shorthand names are constrained significantly
+  +key: Identifier | StringLiteral | NumericLiteral;
+  // destructuring properties cannot have any value
+  +value: DestructuringPattern;
+  +shorthand: false;
+}
+export interface DestructuringObjectPropertyWithShorthandStaticName
+  extends DestructuringObjectPropertyBase {
+  +type: 'Property';
+  +computed: false;
+  // shorthand keys *must* be identifiers
+  +key: Identifier;
+  // shorthand values *must* be identifiers (that look the same as the key)
+  +value: Identifier;
+  +shorthand: true;
+}
+export interface DestructuringObjectPropertyWithComputedName
+  extends DestructuringObjectPropertyBase {
+  +type: 'Property';
+  +computed: true;
+  // computed names can be any expression
+  +key: Expression;
+  // destructuring properties cannot have any value
+  +value: DestructuringPattern;
+  // cannot have a shorthand computed name
+  +shorthand: false;
+}
 
 export interface FunctionExpression extends BaseFunction {
   +id?: Identifier | null;
@@ -449,17 +538,28 @@ 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;
 }
 
+// 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;
-  +left: Pattern | MemberExpression;
+  +left: BindingName | MemberExpression;
   +right: Expression;
 }
 
@@ -491,19 +591,31 @@ interface BaseCallExpression extends BaseNode {
 }
 export interface CallExpression extends BaseCallExpression {
   +type: 'CallExpression';
+  +optional: boolean;
 }
 
 export interface NewExpression extends BaseCallExpression {
   +type: 'NewExpression';
 }
 
-interface BaseMemberExpression extends BaseNode {
+export type MemberExpression =
+  | MemberExpressionWithComputedName
+  | MemberExpressionWithNonComputedName;
+export interface MemberExpressionWithComputedName extends BaseNode {
+  +type: 'MemberExpression';
+  +computed: true;
   +object: Expression | Super;
   +property: Expression;
-  +computed: boolean;
+  +computed: true;
+  +optional: boolean;
 }
-export interface MemberExpression extends BaseMemberExpression {
+export interface MemberExpressionWithNonComputedName extends BaseNode {
   +type: 'MemberExpression';
+  +computed: false;
+  +object: Expression | Super;
+  +property: Identifier | PrivateIdentifier;
+  +computed: false;
+  +optional: boolean;
 }
 
 export type ChainElement = CallExpression | MemberExpression;
@@ -513,14 +625,6 @@ export interface ChainExpression extends BaseNode {
   +expression: ChainElement;
 }
 
-export type Pattern =
-  | Identifier
-  | ObjectPattern
-  | ArrayPattern
-  | RestElement
-  | AssignmentPattern
-  | MemberExpression;
-
 export interface SwitchCase extends BaseNode {
   +type: 'SwitchCase';
   +test?: Expression | null;
@@ -529,7 +633,7 @@ export interface SwitchCase extends BaseNode {
 
 export interface CatchClause extends BaseNode {
   +type: 'CatchClause';
-  +param: Pattern | null;
+  +param: BindingName | null;
   +body: BlockStatement;
 }
 
@@ -542,9 +646,13 @@ export interface Identifier extends BaseNode {
   +optional: boolean;
 }
 
+export interface PrivateIdentifier extends BaseNode {
+  +type: 'PrivateIdentifier';
+  +name: string;
+}
+
 export type Literal =
   | BigIntLiteral
-  | BigIntLiteralLegacy
   | BooleanLiteral
   | NullLiteral
   | NumericLiteral
@@ -556,24 +664,28 @@ export interface BigIntLiteral extends BaseNode {
   +value: null /* | bigint */;
   +bigint: string;
   +raw: string;
+  +literalType: 'bigint';
 }
 
 export interface BooleanLiteral extends BaseNode {
   +type: 'Literal';
   +value: boolean;
   +raw: 'true' | 'false';
+  +literalType: 'boolean';
 }
 
 export interface NullLiteral extends BaseNode {
   +type: 'Literal';
   +value: null;
   +raw: 'null';
+  +literalType: 'null';
 }
 
 export interface NumericLiteral extends BaseNode {
   +type: 'Literal';
   +value: number;
   +raw: string;
+  +literalType: 'numeric';
 }
 
 export interface RegExpLiteral extends BaseNode {
@@ -584,12 +696,14 @@ export interface RegExpLiteral extends BaseNode {
     +flags: string,
   };
   +raw: string;
+  +literalType: 'regexp';
 }
 
 export interface StringLiteral extends BaseNode {
   +type: 'Literal';
   +value: string;
   +raw: string;
+  +literalType: 'string';
 }
 
 export type UnaryOperator =
@@ -601,7 +715,7 @@ export type UnaryOperator =
   | 'void'
   | 'delete';
 
-export type BinaryOperator =
+export type BinaryOperatorWithoutIn =
   | '=='
   | '!='
   | '==='
@@ -622,10 +736,11 @@ export type BinaryOperator =
   | '|'
   | '^'
   | '&'
-  | 'in'
   | 'instanceof';
 
-export type LogicalOperator = '||' | '&&';
+export type BinaryOperator = BinaryOperatorWithoutIn | 'in';
+
+export type LogicalOperator = '||' | '&&' | '??';
 
 export type AssignmentOperator =
   | '='
@@ -640,7 +755,11 @@ export type AssignmentOperator =
   | '>>>='
   | '|='
   | '^='
-  | '&=';
+  | '&='
+  // not yet supported, but future proofing
+  | '||='
+  | '&&='
+  | '??=';
 
 export type UpdateOperator = '++' | '--';
 
@@ -691,27 +810,27 @@ export interface TemplateElement extends BaseNode {
 
 export interface ObjectPattern extends BaseNode {
   +type: 'ObjectPattern';
-  +properties: $ReadOnlyArray<AssignmentProperty | RestElement>;
+  +properties: $ReadOnlyArray<DestructuringObjectProperty | RestElement>;
   // if used as a VariableDeclarator.id
   +typeAnnotation: TypeAnnotation | null;
 }
 
 export interface ArrayPattern extends BaseNode {
   +type: 'ArrayPattern';
-  +elements: $ReadOnlyArray<Pattern>;
-
+  // an element will be null if the pattern contains a hole: `[a,,b]`
+  +elements: $ReadOnlyArray<?DestructuringPattern>;
   +typeAnnotation: TypeAnnotation | null;
 }
 
 export interface RestElement extends BaseNode {
   +type: 'RestElement';
-  +argument: Pattern;
+  +argument: RestElementPattern;
   // the Pattern owns the typeAnnotation
 }
 
 export interface AssignmentPattern extends BaseNode {
   +type: 'AssignmentPattern';
-  +left: Pattern;
+  +left: BindingName;
   +right: Expression;
 }
 
@@ -726,21 +845,80 @@ interface BaseClass extends BaseNode {
   +decorators: $ReadOnlyArray<Decorator>;
 }
 
+export type PropertyName =
+  | ClassPropertyNameComputed
+  | ClassPropertyNameNonComputed;
+export type ClassPropertyNameComputed = Expression;
+export type ClassPropertyNameNonComputed =
+  | PrivateIdentifier
+  | Identifier
+  | StringLiteral;
+
+export type ClassMember = PropertyDefinition | MethodDefinition;
+export type ClassMemberWithNonComputedName =
+  | PropertyDefinitionWithNonComputedName
+  | MethodDefinitionConstructor
+  | MethodDefinitionWithNonComputedName;
 export interface ClassBody extends BaseNode {
   +type: 'ClassBody';
-  +body: $ReadOnlyArray<
-    ClassProperty | ClassPrivateProperty | MethodDefinition,
-  >;
+  +body: $ReadOnlyArray<ClassMember>;
 }
 
-export interface MethodDefinition extends BaseNode {
-  +type: 'MethodDefinition';
-  +key: Expression;
+export type MethodDefinition =
+  | MethodDefinitionConstructor
+  | MethodDefinitionWithComputedName
+  | MethodDefinitionWithNonComputedName;
+interface MethodDefinitionBase extends BaseNode {
   +value: FunctionExpression;
-  +kind: 'constructor' | 'method' | 'get' | 'set';
-  +computed: boolean;
+}
+export interface MethodDefinitionConstructor extends MethodDefinitionBase {
+  +type: 'MethodDefinition';
+  +key: Identifier | StringLiteral;
+  +kind: 'constructor';
+  +computed: false;
+  +static: false;
+}
+export interface MethodDefinitionWithComputedName extends MethodDefinitionBase {
+  +type: 'MethodDefinition';
+  +key: ClassPropertyNameComputed;
+  +kind: 'method' | 'get' | 'set';
+  +computed: true;
   +static: boolean;
 }
+export interface MethodDefinitionWithNonComputedName
+  extends MethodDefinitionBase {
+  +type: 'MethodDefinition';
+  +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';
@@ -772,8 +950,7 @@ export type ModuleSpecifier =
   | ImportSpecifier
   | ImportDefaultSpecifier
   | ImportNamespaceSpecifier
-  | ExportSpecifier
-  | ExportNamespaceSpecifier;
+  | ExportSpecifier;
 
 export interface ImportDeclaration extends BaseNode {
   +type: 'ImportDeclaration';
@@ -814,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';
 }
@@ -830,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 {
@@ -863,6 +1048,7 @@ export type TypeAnnotationType =
   | VoidTypeAnnotation
   | StringLiteralTypeAnnotation
   | NumberLiteralTypeAnnotation
+  | BigIntLiteralTypeAnnotation
   | BooleanLiteralTypeAnnotation
   | ArrayTypeAnnotation
   | NullableTypeAnnotation
@@ -942,12 +1128,18 @@ export interface VoidTypeAnnotation extends BaseNode {
 export interface StringLiteralTypeAnnotation extends BaseNode {
   +type: 'StringLiteralTypeAnnotation';
   +value: string;
+  +raw: string;
 }
 export interface NumberLiteralTypeAnnotation extends BaseNode {
   +type: 'NumberLiteralTypeAnnotation';
   +value: number;
   +raw: string;
 }
+export interface BigIntLiteralTypeAnnotation extends BaseNode {
+  +type: 'BigIntLiteralTypeAnnotation';
+  +value: null;
+  +raw: string;
+}
 export interface BooleanLiteralTypeAnnotation extends BaseNode {
   +type: 'BooleanLiteralTypeAnnotation';
   +value: boolean;
@@ -966,7 +1158,7 @@ export interface ExistsTypeAnnotation extends BaseNode {
 }
 export interface GenericTypeAnnotation extends BaseNode {
   +type: 'GenericTypeAnnotation';
-  +id: Identifier;
+  +id: Identifier | QualifiedTypeIdentifier;
   +typeParameters: null | TypeParameterInstantiation;
 }
 export interface QualifiedTypeIdentifier extends BaseNode {
@@ -976,7 +1168,7 @@ export interface QualifiedTypeIdentifier extends BaseNode {
 }
 export interface TypeofTypeAnnotation extends BaseNode {
   +type: 'TypeofTypeAnnotation';
-  +argument: GenericTypeAnnotation | QualifiedTypeIdentifier;
+  +argument: TypeAnnotationType;
 }
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
@@ -1099,17 +1291,6 @@ export interface InterfaceExtends extends BaseNode {
   +typeParameters: null | TypeParameterDeclaration;
 }
 
-interface ClassPropertyBase extends BaseNode {
-  +key: Identifier;
-  +value: null | Literal;
-  +typeAnnotation: null | TypeAnnotationType;
-  +static: boolean;
-  +variance: null | Variance;
-  +declare: boolean;
-  // hermes always emit this as false
-  +optional: false;
-}
-
 export interface ClassImplements extends BaseNode {
   +type: 'ClassImplements';
   +id: Identifier;
@@ -1201,6 +1382,19 @@ export interface EnumDefaultedMember extends BaseNode {
  * Declare nodes *
  *****************/
 
+export type DeclaredNode =
+  | DeclareClass
+  | DeclareVariable
+  | DeclareFunction
+  | DeclareModule
+  | DeclareInterface
+  | DeclareTypeAlias
+  | DeclareOpaqueType
+  | DeclareExportAllDeclaration
+  | DeclareExportDeclaration
+  | DeclareModuleExports
+  | DeclaredPredicate;
+
 export interface DeclareClass extends BaseNode {
   +type: 'DeclareClass';
   +id: Identifier;
@@ -1219,7 +1413,7 @@ export interface DeclareVariable extends BaseNode {
 export interface DeclareFunction extends BaseNode {
   +type: 'DeclareFunction';
   +id: Identifier;
-  +predicate: InferredPredicate | null;
+  +predicate: InferredPredicate | DeclaredPredicate | null;
 }
 
 export interface DeclareModule extends BaseNode {
@@ -1251,7 +1445,7 @@ export interface DeclareExportDeclaration extends BaseNode {
   +type: 'DeclareExportDeclaration';
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
   +declaration:
-    | TypeAnnotationType
+    | TypeAlias
     | DeclareClass
     | DeclareFunction
     | DeclareOpaqueType
@@ -1390,42 +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 interface OptionalMemberExpression extends BaseMemberExpression {
-  +type: 'OptionalMemberExpression';
-  +optional: boolean;
-}
-
-// `ExportAllDeclaration` is the new standard for `export * as y from 'z'`
-export interface ExportNamespaceSpecifier extends BaseNode {
-  +type: 'ExportNamespaceSpecifier';
-  +exported: Identifier;
-}
-
-// `Literal` is the new standard for bigints (see the BigIntLiteral interface)
-export interface BigIntLiteralLegacy extends BaseNode {
-  +type: 'BigIntLiteral';
-  +value: null /* | bigint */;
-  +bigint: string;
-}
-
-// `PropertyDefinition` is the new standard for all class properties
-export interface ClassProperty extends ClassPropertyBase {
-  +type: 'ClassProperty';
-  +computed: false; // flow itself doesn't support computed ClassProperties, even though they might parse fine.
-}
-export interface ClassPrivateProperty extends ClassPropertyBase {
-  +type: 'ClassPrivateProperty';
-}
-
-// `PrivateIdentifier` is the new standard for #private identifiers
-export interface PrivateName extends BaseNode {
-  +type: 'PrivateName';
-  +id: Identifier;
-}
-
 export {};