ast-types 0.14.2 → 0.15.0

package/gen/namedTypes.d.ts

@@ -220,7 +220,7 @@ export declare namespace namedTypes {
     }
     interface AssignmentExpression extends Omit<Expression, "type"> {
         type: "AssignmentExpression";
-        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=";
+        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=";
         left: K.PatternKind | K.MemberExpressionKind;
         right: K.ExpressionKind;
     }
@@ -447,7 +447,7 @@ export declare namespace namedTypes {
     interface TemplateLiteral extends Omit<Expression, "type"> {
         type: "TemplateLiteral";
         quasis: K.TemplateElementKind[];
-        expressions: K.ExpressionKind[];
+        expressions: K.ExpressionKind[] | K.TSTypeKind[];
     }
     interface TemplateElement extends Omit<Node, "type"> {
         type: "TemplateElement";
@@ -491,6 +491,52 @@ export declare namespace namedTypes {
         type: "OptionalMemberExpression";
         optional?: boolean;
     }
+    interface StaticBlock extends Omit<Node, "type"> {
+        type: "StaticBlock";
+        body: K.StatementKind[];
+    }
+    interface Decorator extends Omit<Node, "type"> {
+        type: "Decorator";
+        expression: K.ExpressionKind;
+    }
+    interface PrivateName extends Omit<Expression, "type">, Omit<Pattern, "type"> {
+        type: "PrivateName";
+        id: K.IdentifierKind;
+    }
+    interface ClassPrivateProperty extends Omit<ClassProperty, "type" | "key" | "value"> {
+        type: "ClassPrivateProperty";
+        key: K.PrivateNameKind;
+        value?: K.ExpressionKind | null;
+    }
+    interface ImportAttribute extends Omit<Node, "type"> {
+        type: "ImportAttribute";
+        key: K.IdentifierKind;
+        value: string;
+    }
+    interface RecordExpression extends Omit<Expression, "type"> {
+        type: "RecordExpression";
+        properties: (K.ObjectPropertyKind | K.ObjectMethodKind | K.SpreadElementKind)[];
+    }
+    interface ObjectMethod extends Omit<Node, "type">, Omit<Function, "type" | "params" | "body" | "generator" | "async"> {
+        type: "ObjectMethod";
+        kind: "method" | "get" | "set";
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        params: K.PatternKind[];
+        body: K.BlockStatementKind;
+        computed?: boolean;
+        generator?: boolean;
+        async?: boolean;
+        accessibility?: K.LiteralKind | null;
+        decorators?: K.DecoratorKind[] | null;
+    }
+    interface TupleExpression extends Omit<Expression, "type"> {
+        type: "TupleExpression";
+        elements: (K.ExpressionKind | K.SpreadElementKind | null)[];
+    }
+    interface ModuleExpression extends Omit<Node, "type"> {
+        type: "ModuleExpression";
+        body: K.ProgramKind;
+    }
     interface JSXAttribute extends Omit<Node, "type"> {
         type: "JSXAttribute";
         name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;
@@ -562,19 +608,6 @@ export declare namespace namedTypes {
     interface JSXClosingFragment extends Omit<Node, "type"> {
         type: "JSXClosingFragment";
     }
-    interface Decorator extends Omit<Node, "type"> {
-        type: "Decorator";
-        expression: K.ExpressionKind;
-    }
-    interface PrivateName extends Omit<Expression, "type">, Omit<Pattern, "type"> {
-        type: "PrivateName";
-        id: K.IdentifierKind;
-    }
-    interface ClassPrivateProperty extends Omit<ClassProperty, "type" | "key" | "value"> {
-        type: "ClassPrivateProperty";
-        key: K.PrivateNameKind;
-        value?: K.ExpressionKind | null;
-    }
     interface TypeParameterDeclaration extends Omit<Node, "type"> {
         type: "TypeParameterDeclaration";
         params: K.TypeParameterKind[];
@@ -758,6 +791,17 @@ export declare namespace namedTypes {
         object: K.IdentifierKind;
         property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;
     }
+    interface IndexedAccessType extends Omit<FlowType, "type"> {
+        type: "IndexedAccessType";
+        objectType: K.FlowTypeKind;
+        indexType: K.FlowTypeKind;
+    }
+    interface OptionalIndexedAccessType extends Omit<FlowType, "type"> {
+        type: "OptionalIndexedAccessType";
+        objectType: K.FlowTypeKind;
+        indexType: K.FlowTypeKind;
+        optional: boolean;
+    }
     interface UnionTypeAnnotation extends Omit<FlowType, "type"> {
         type: "UnionTypeAnnotation";
         types: K.FlowTypeKind[];
@@ -989,6 +1033,14 @@ export declare namespace namedTypes {
             raw: string;
         };
     }
+    interface DecimalLiteral extends Omit<Literal, "type" | "value"> {
+        type: "DecimalLiteral";
+        value: string;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
+    }
     interface NullLiteral extends Omit<Literal, "type" | "value"> {
         type: "NullLiteral";
         value?: null;
@@ -1003,18 +1055,6 @@ export declare namespace namedTypes {
         flags: string;
         value?: RegExp;
     }
-    interface ObjectMethod extends Omit<Node, "type">, Omit<Function, "type" | "params" | "body" | "generator" | "async"> {
-        type: "ObjectMethod";
-        kind: "method" | "get" | "set";
-        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
-        params: K.PatternKind[];
-        body: K.BlockStatementKind;
-        computed?: boolean;
-        generator?: boolean;
-        async?: boolean;
-        accessibility?: K.LiteralKind | null;
-        decorators?: K.DecoratorKind[] | null;
-    }
     interface ClassMethod extends Omit<Declaration, "type">, Omit<Function, "type" | "body"> {
         type: "ClassMethod";
         key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
@@ -1054,6 +1094,13 @@ export declare namespace namedTypes {
     interface Import extends Omit<Expression, "type"> {
         type: "Import";
     }
+    interface V8IntrinsicIdentifier extends Omit<Expression, "type"> {
+        type: "V8IntrinsicIdentifier";
+        name: string;
+    }
+    interface TopicReference extends Omit<Expression, "type"> {
+        type: "TopicReference";
+    }
     interface TSQualifiedName extends Omit<Node, "type"> {
         type: "TSQualifiedName";
         left: K.IdentifierKind | K.TSQualifiedNameKind;
@@ -1117,6 +1164,9 @@ export declare namespace namedTypes {
     interface TSVoidKeyword extends Omit<TSType, "type"> {
         type: "TSVoidKeyword";
     }
+    interface TSIntrinsicKeyword extends Omit<TSType, "type"> {
+        type: "TSIntrinsicKeyword";
+    }
     interface TSThisType extends Omit<TSType, "type"> {
         type: "TSThisType";
     }
@@ -1345,7 +1395,7 @@ export declare namespace namedTypes {
         readonly?: boolean;
         parameter: K.IdentifierKind | K.AssignmentPatternKind;
     }
-    type ASTNode = File | Program | Identifier | BlockStatement | EmptyStatement | ExpressionStatement | IfStatement | LabeledStatement | BreakStatement | ContinueStatement | WithStatement | SwitchStatement | SwitchCase | ReturnStatement | ThrowStatement | TryStatement | CatchClause | WhileStatement | DoWhileStatement | ForStatement | VariableDeclaration | ForInStatement | DebuggerStatement | FunctionDeclaration | FunctionExpression | VariableDeclarator | ThisExpression | ArrayExpression | ObjectExpression | Property | Literal | SequenceExpression | UnaryExpression | BinaryExpression | AssignmentExpression | MemberExpression | UpdateExpression | LogicalExpression | ConditionalExpression | NewExpression | CallExpression | RestElement | TypeAnnotation | TSTypeAnnotation | SpreadElementPattern | ArrowFunctionExpression | ForOfStatement | YieldExpression | GeneratorExpression | ComprehensionBlock | ComprehensionExpression | ObjectProperty | PropertyPattern | ObjectPattern | ArrayPattern | SpreadElement | AssignmentPattern | MethodDefinition | ClassPropertyDefinition | ClassProperty | ClassBody | ClassDeclaration | ClassExpression | Super | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportDeclaration | ExportNamedDeclaration | ExportSpecifier | ExportDefaultDeclaration | ExportAllDeclaration | TaggedTemplateExpression | TemplateLiteral | TemplateElement | MetaProperty | AwaitExpression | SpreadProperty | SpreadPropertyPattern | ImportExpression | ChainExpression | OptionalCallExpression | OptionalMemberExpression | JSXAttribute | JSXIdentifier | JSXNamespacedName | JSXExpressionContainer | JSXElement | JSXFragment | JSXMemberExpression | JSXSpreadAttribute | JSXEmptyExpression | JSXText | JSXSpreadChild | JSXOpeningElement | JSXClosingElement | JSXOpeningFragment | JSXClosingFragment | Decorator | PrivateName | ClassPrivateProperty | TypeParameterDeclaration | TSTypeParameterDeclaration | TypeParameterInstantiation | TSTypeParameterInstantiation | ClassImplements | TSExpressionWithTypeArguments | AnyTypeAnnotation | EmptyTypeAnnotation | MixedTypeAnnotation | VoidTypeAnnotation | SymbolTypeAnnotation | NumberTypeAnnotation | BigIntTypeAnnotation | NumberLiteralTypeAnnotation | NumericLiteralTypeAnnotation | BigIntLiteralTypeAnnotation | StringTypeAnnotation | StringLiteralTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullableTypeAnnotation | NullLiteralTypeAnnotation | NullTypeAnnotation | ThisTypeAnnotation | ExistsTypeAnnotation | ExistentialTypeParam | FunctionTypeAnnotation | FunctionTypeParam | ArrayTypeAnnotation | ObjectTypeAnnotation | ObjectTypeProperty | ObjectTypeSpreadProperty | ObjectTypeIndexer | ObjectTypeCallProperty | ObjectTypeInternalSlot | Variance | QualifiedTypeIdentifier | GenericTypeAnnotation | MemberTypeAnnotation | UnionTypeAnnotation | IntersectionTypeAnnotation | TypeofTypeAnnotation | TypeParameter | InterfaceTypeAnnotation | InterfaceExtends | InterfaceDeclaration | DeclareInterface | TypeAlias | DeclareTypeAlias | OpaqueType | DeclareOpaqueType | TypeCastExpression | TupleTypeAnnotation | DeclareVariable | DeclareFunction | DeclareClass | DeclareModule | DeclareModuleExports | DeclareExportDeclaration | ExportBatchSpecifier | DeclareExportAllDeclaration | InferredPredicate | DeclaredPredicate | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | ExportDeclaration | Block | Line | Noop | DoExpression | BindExpression | ParenthesizedExpression | ExportNamespaceSpecifier | ExportDefaultSpecifier | CommentBlock | CommentLine | Directive | DirectiveLiteral | InterpreterDirective | StringLiteral | NumericLiteral | BigIntLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ObjectMethod | ClassMethod | ClassPrivateMethod | RestProperty | ForAwaitStatement | Import | TSQualifiedName | TSTypeReference | TSAsExpression | TSNonNullExpression | TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSArrayType | TSLiteralType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSTypeParameter | TSParenthesizedType | TSFunctionType | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSMappedType | TSTupleType | TSNamedTupleMember | TSRestType | TSOptionalType | TSIndexedAccessType | TSTypeOperator | TSIndexSignature | TSPropertySignature | TSMethodSignature | TSTypePredicate | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSEnumMember | TSTypeQuery | TSImportType | TSTypeLiteral | TSTypeAssertion | TSEnumDeclaration | TSTypeAliasDeclaration | TSModuleBlock | TSModuleDeclaration | TSImportEqualsDeclaration | TSExternalModuleReference | TSExportAssignment | TSNamespaceExportDeclaration | TSInterfaceBody | TSInterfaceDeclaration | TSParameterProperty;
+    type ASTNode = File | Program | Identifier | BlockStatement | EmptyStatement | ExpressionStatement | IfStatement | LabeledStatement | BreakStatement | ContinueStatement | WithStatement | SwitchStatement | SwitchCase | ReturnStatement | ThrowStatement | TryStatement | CatchClause | WhileStatement | DoWhileStatement | ForStatement | VariableDeclaration | ForInStatement | DebuggerStatement | FunctionDeclaration | FunctionExpression | VariableDeclarator | ThisExpression | ArrayExpression | ObjectExpression | Property | Literal | SequenceExpression | UnaryExpression | BinaryExpression | AssignmentExpression | MemberExpression | UpdateExpression | LogicalExpression | ConditionalExpression | NewExpression | CallExpression | RestElement | TypeAnnotation | TSTypeAnnotation | SpreadElementPattern | ArrowFunctionExpression | ForOfStatement | YieldExpression | GeneratorExpression | ComprehensionBlock | ComprehensionExpression | ObjectProperty | PropertyPattern | ObjectPattern | ArrayPattern | SpreadElement | AssignmentPattern | MethodDefinition | ClassPropertyDefinition | ClassProperty | ClassBody | ClassDeclaration | ClassExpression | Super | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportDeclaration | ExportNamedDeclaration | ExportSpecifier | ExportDefaultDeclaration | ExportAllDeclaration | TaggedTemplateExpression | TemplateLiteral | TemplateElement | MetaProperty | AwaitExpression | SpreadProperty | SpreadPropertyPattern | ImportExpression | ChainExpression | OptionalCallExpression | OptionalMemberExpression | StaticBlock | Decorator | PrivateName | ClassPrivateProperty | ImportAttribute | RecordExpression | ObjectMethod | TupleExpression | ModuleExpression | JSXAttribute | JSXIdentifier | JSXNamespacedName | JSXExpressionContainer | JSXElement | JSXFragment | JSXMemberExpression | JSXSpreadAttribute | JSXEmptyExpression | JSXText | JSXSpreadChild | JSXOpeningElement | JSXClosingElement | JSXOpeningFragment | JSXClosingFragment | TypeParameterDeclaration | TSTypeParameterDeclaration | TypeParameterInstantiation | TSTypeParameterInstantiation | ClassImplements | TSExpressionWithTypeArguments | AnyTypeAnnotation | EmptyTypeAnnotation | MixedTypeAnnotation | VoidTypeAnnotation | SymbolTypeAnnotation | NumberTypeAnnotation | BigIntTypeAnnotation | NumberLiteralTypeAnnotation | NumericLiteralTypeAnnotation | BigIntLiteralTypeAnnotation | StringTypeAnnotation | StringLiteralTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullableTypeAnnotation | NullLiteralTypeAnnotation | NullTypeAnnotation | ThisTypeAnnotation | ExistsTypeAnnotation | ExistentialTypeParam | FunctionTypeAnnotation | FunctionTypeParam | ArrayTypeAnnotation | ObjectTypeAnnotation | ObjectTypeProperty | ObjectTypeSpreadProperty | ObjectTypeIndexer | ObjectTypeCallProperty | ObjectTypeInternalSlot | Variance | QualifiedTypeIdentifier | GenericTypeAnnotation | MemberTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType | UnionTypeAnnotation | IntersectionTypeAnnotation | TypeofTypeAnnotation | TypeParameter | InterfaceTypeAnnotation | InterfaceExtends | InterfaceDeclaration | DeclareInterface | TypeAlias | DeclareTypeAlias | OpaqueType | DeclareOpaqueType | TypeCastExpression | TupleTypeAnnotation | DeclareVariable | DeclareFunction | DeclareClass | DeclareModule | DeclareModuleExports | DeclareExportDeclaration | ExportBatchSpecifier | DeclareExportAllDeclaration | InferredPredicate | DeclaredPredicate | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | ExportDeclaration | Block | Line | Noop | DoExpression | BindExpression | ParenthesizedExpression | ExportNamespaceSpecifier | ExportDefaultSpecifier | CommentBlock | CommentLine | Directive | DirectiveLiteral | InterpreterDirective | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ClassMethod | ClassPrivateMethod | RestProperty | ForAwaitStatement | Import | V8IntrinsicIdentifier | TopicReference | TSQualifiedName | TSTypeReference | TSAsExpression | TSNonNullExpression | TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSIntrinsicKeyword | TSThisType | TSArrayType | TSLiteralType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSTypeParameter | TSParenthesizedType | TSFunctionType | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSMappedType | TSTupleType | TSNamedTupleMember | TSRestType | TSOptionalType | TSIndexedAccessType | TSTypeOperator | TSIndexSignature | TSPropertySignature | TSMethodSignature | TSTypePredicate | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSEnumMember | TSTypeQuery | TSImportType | TSTypeLiteral | TSTypeAssertion | TSEnumDeclaration | TSTypeAliasDeclaration | TSModuleBlock | TSModuleDeclaration | TSImportEqualsDeclaration | TSExternalModuleReference | TSExportAssignment | TSNamespaceExportDeclaration | TSInterfaceBody | TSInterfaceDeclaration | TSParameterProperty;
     let Printable: Type<Printable>;
     let SourceLocation: Type<SourceLocation>;
     let Node: Type<Node>;
@@ -1442,6 +1492,15 @@ export declare namespace namedTypes {
     let ChainExpression: Type<ChainExpression>;
     let OptionalCallExpression: Type<OptionalCallExpression>;
     let OptionalMemberExpression: Type<OptionalMemberExpression>;
+    let StaticBlock: Type<StaticBlock>;
+    let Decorator: Type<Decorator>;
+    let PrivateName: Type<PrivateName>;
+    let ClassPrivateProperty: Type<ClassPrivateProperty>;
+    let ImportAttribute: Type<ImportAttribute>;
+    let RecordExpression: Type<RecordExpression>;
+    let ObjectMethod: Type<ObjectMethod>;
+    let TupleExpression: Type<TupleExpression>;
+    let ModuleExpression: Type<ModuleExpression>;
     let JSXAttribute: Type<JSXAttribute>;
     let JSXIdentifier: Type<JSXIdentifier>;
     let JSXNamespacedName: Type<JSXNamespacedName>;
@@ -1457,9 +1516,6 @@ export declare namespace namedTypes {
     let JSXClosingElement: Type<JSXClosingElement>;
     let JSXOpeningFragment: Type<JSXOpeningFragment>;
     let JSXClosingFragment: Type<JSXClosingFragment>;
-    let Decorator: Type<Decorator>;
-    let PrivateName: Type<PrivateName>;
-    let ClassPrivateProperty: Type<ClassPrivateProperty>;
     let TypeParameterDeclaration: Type<TypeParameterDeclaration>;
     let TSTypeParameterDeclaration: Type<TSTypeParameterDeclaration>;
     let TypeParameterInstantiation: Type<TypeParameterInstantiation>;
@@ -1503,6 +1559,8 @@ export declare namespace namedTypes {
     let QualifiedTypeIdentifier: Type<QualifiedTypeIdentifier>;
     let GenericTypeAnnotation: Type<GenericTypeAnnotation>;
     let MemberTypeAnnotation: Type<MemberTypeAnnotation>;
+    let IndexedAccessType: Type<IndexedAccessType>;
+    let OptionalIndexedAccessType: Type<OptionalIndexedAccessType>;
     let UnionTypeAnnotation: Type<UnionTypeAnnotation>;
     let IntersectionTypeAnnotation: Type<IntersectionTypeAnnotation>;
     let TypeofTypeAnnotation: Type<TypeofTypeAnnotation>;
@@ -1554,15 +1612,17 @@ export declare namespace namedTypes {
     let StringLiteral: Type<StringLiteral>;
     let NumericLiteral: Type<NumericLiteral>;
     let BigIntLiteral: Type<BigIntLiteral>;
+    let DecimalLiteral: Type<DecimalLiteral>;
     let NullLiteral: Type<NullLiteral>;
     let BooleanLiteral: Type<BooleanLiteral>;
     let RegExpLiteral: Type<RegExpLiteral>;
-    let ObjectMethod: Type<ObjectMethod>;
     let ClassMethod: Type<ClassMethod>;
     let ClassPrivateMethod: Type<ClassPrivateMethod>;
     let RestProperty: Type<RestProperty>;
     let ForAwaitStatement: Type<ForAwaitStatement>;
     let Import: Type<Import>;
+    let V8IntrinsicIdentifier: Type<V8IntrinsicIdentifier>;
+    let TopicReference: Type<TopicReference>;
     let TSQualifiedName: Type<TSQualifiedName>;
     let TSTypeReference: Type<TSTypeReference>;
     let TSHasOptionalTypeParameters: Type<TSHasOptionalTypeParameters>;
@@ -1581,6 +1641,7 @@ export declare namespace namedTypes {
     let TSUndefinedKeyword: Type<TSUndefinedKeyword>;
     let TSUnknownKeyword: Type<TSUnknownKeyword>;
     let TSVoidKeyword: Type<TSVoidKeyword>;
+    let TSIntrinsicKeyword: Type<TSIntrinsicKeyword>;
     let TSThisType: Type<TSThisType>;
     let TSArrayType: Type<TSArrayType>;
     let TSLiteralType: Type<TSLiteralType>;
@@ -1721,6 +1782,15 @@ export interface NamedTypes {
     ChainExpression: Type<namedTypes.ChainExpression>;
     OptionalCallExpression: Type<namedTypes.OptionalCallExpression>;
     OptionalMemberExpression: Type<namedTypes.OptionalMemberExpression>;
+    StaticBlock: Type<namedTypes.StaticBlock>;
+    Decorator: Type<namedTypes.Decorator>;
+    PrivateName: Type<namedTypes.PrivateName>;
+    ClassPrivateProperty: Type<namedTypes.ClassPrivateProperty>;
+    ImportAttribute: Type<namedTypes.ImportAttribute>;
+    RecordExpression: Type<namedTypes.RecordExpression>;
+    ObjectMethod: Type<namedTypes.ObjectMethod>;
+    TupleExpression: Type<namedTypes.TupleExpression>;
+    ModuleExpression: Type<namedTypes.ModuleExpression>;
     JSXAttribute: Type<namedTypes.JSXAttribute>;
     JSXIdentifier: Type<namedTypes.JSXIdentifier>;
     JSXNamespacedName: Type<namedTypes.JSXNamespacedName>;
@@ -1736,9 +1806,6 @@ export interface NamedTypes {
     JSXClosingElement: Type<namedTypes.JSXClosingElement>;
     JSXOpeningFragment: Type<namedTypes.JSXOpeningFragment>;
     JSXClosingFragment: Type<namedTypes.JSXClosingFragment>;
-    Decorator: Type<namedTypes.Decorator>;
-    PrivateName: Type<namedTypes.PrivateName>;
-    ClassPrivateProperty: Type<namedTypes.ClassPrivateProperty>;
     TypeParameterDeclaration: Type<namedTypes.TypeParameterDeclaration>;
     TSTypeParameterDeclaration: Type<namedTypes.TSTypeParameterDeclaration>;
     TypeParameterInstantiation: Type<namedTypes.TypeParameterInstantiation>;
@@ -1782,6 +1849,8 @@ export interface NamedTypes {
     QualifiedTypeIdentifier: Type<namedTypes.QualifiedTypeIdentifier>;
     GenericTypeAnnotation: Type<namedTypes.GenericTypeAnnotation>;
     MemberTypeAnnotation: Type<namedTypes.MemberTypeAnnotation>;
+    IndexedAccessType: Type<namedTypes.IndexedAccessType>;
+    OptionalIndexedAccessType: Type<namedTypes.OptionalIndexedAccessType>;
     UnionTypeAnnotation: Type<namedTypes.UnionTypeAnnotation>;
     IntersectionTypeAnnotation: Type<namedTypes.IntersectionTypeAnnotation>;
     TypeofTypeAnnotation: Type<namedTypes.TypeofTypeAnnotation>;
@@ -1833,15 +1902,17 @@ export interface NamedTypes {
     StringLiteral: Type<namedTypes.StringLiteral>;
     NumericLiteral: Type<namedTypes.NumericLiteral>;
     BigIntLiteral: Type<namedTypes.BigIntLiteral>;
+    DecimalLiteral: Type<namedTypes.DecimalLiteral>;
     NullLiteral: Type<namedTypes.NullLiteral>;
     BooleanLiteral: Type<namedTypes.BooleanLiteral>;
     RegExpLiteral: Type<namedTypes.RegExpLiteral>;
-    ObjectMethod: Type<namedTypes.ObjectMethod>;
     ClassMethod: Type<namedTypes.ClassMethod>;
     ClassPrivateMethod: Type<namedTypes.ClassPrivateMethod>;
     RestProperty: Type<namedTypes.RestProperty>;
     ForAwaitStatement: Type<namedTypes.ForAwaitStatement>;
     Import: Type<namedTypes.Import>;
+    V8IntrinsicIdentifier: Type<namedTypes.V8IntrinsicIdentifier>;
+    TopicReference: Type<namedTypes.TopicReference>;
     TSQualifiedName: Type<namedTypes.TSQualifiedName>;
     TSTypeReference: Type<namedTypes.TSTypeReference>;
     TSHasOptionalTypeParameters: Type<namedTypes.TSHasOptionalTypeParameters>;
@@ -1860,6 +1931,7 @@ export interface NamedTypes {
     TSUndefinedKeyword: Type<namedTypes.TSUndefinedKeyword>;
     TSUnknownKeyword: Type<namedTypes.TSUnknownKeyword>;
     TSVoidKeyword: Type<namedTypes.TSVoidKeyword>;
+    TSIntrinsicKeyword: Type<namedTypes.TSIntrinsicKeyword>;
     TSThisType: Type<namedTypes.TSThisType>;
     TSArrayType: Type<namedTypes.TSArrayType>;
     TSLiteralType: Type<namedTypes.TSLiteralType>;

package/gen/visitor.d.ts

@@ -98,6 +98,15 @@ export interface Visitor<M = {}> {
     visitChainExpression?(this: Context & M, path: NodePath<namedTypes.ChainExpression>): any;
     visitOptionalCallExpression?(this: Context & M, path: NodePath<namedTypes.OptionalCallExpression>): any;
     visitOptionalMemberExpression?(this: Context & M, path: NodePath<namedTypes.OptionalMemberExpression>): any;
+    visitStaticBlock?(this: Context & M, path: NodePath<namedTypes.StaticBlock>): any;
+    visitDecorator?(this: Context & M, path: NodePath<namedTypes.Decorator>): any;
+    visitPrivateName?(this: Context & M, path: NodePath<namedTypes.PrivateName>): any;
+    visitClassPrivateProperty?(this: Context & M, path: NodePath<namedTypes.ClassPrivateProperty>): any;
+    visitImportAttribute?(this: Context & M, path: NodePath<namedTypes.ImportAttribute>): any;
+    visitRecordExpression?(this: Context & M, path: NodePath<namedTypes.RecordExpression>): any;
+    visitObjectMethod?(this: Context & M, path: NodePath<namedTypes.ObjectMethod>): any;
+    visitTupleExpression?(this: Context & M, path: NodePath<namedTypes.TupleExpression>): any;
+    visitModuleExpression?(this: Context & M, path: NodePath<namedTypes.ModuleExpression>): any;
     visitJSXAttribute?(this: Context & M, path: NodePath<namedTypes.JSXAttribute>): any;
     visitJSXIdentifier?(this: Context & M, path: NodePath<namedTypes.JSXIdentifier>): any;
     visitJSXNamespacedName?(this: Context & M, path: NodePath<namedTypes.JSXNamespacedName>): any;
@@ -113,9 +122,6 @@ export interface Visitor<M = {}> {
     visitJSXClosingElement?(this: Context & M, path: NodePath<namedTypes.JSXClosingElement>): any;
     visitJSXOpeningFragment?(this: Context & M, path: NodePath<namedTypes.JSXOpeningFragment>): any;
     visitJSXClosingFragment?(this: Context & M, path: NodePath<namedTypes.JSXClosingFragment>): any;
-    visitDecorator?(this: Context & M, path: NodePath<namedTypes.Decorator>): any;
-    visitPrivateName?(this: Context & M, path: NodePath<namedTypes.PrivateName>): any;
-    visitClassPrivateProperty?(this: Context & M, path: NodePath<namedTypes.ClassPrivateProperty>): any;
     visitTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TypeParameterDeclaration>): any;
     visitTSTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TSTypeParameterDeclaration>): any;
     visitTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TypeParameterInstantiation>): any;
@@ -159,6 +165,8 @@ export interface Visitor<M = {}> {
     visitQualifiedTypeIdentifier?(this: Context & M, path: NodePath<namedTypes.QualifiedTypeIdentifier>): any;
     visitGenericTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.GenericTypeAnnotation>): any;
     visitMemberTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.MemberTypeAnnotation>): any;
+    visitIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.IndexedAccessType>): any;
+    visitOptionalIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.OptionalIndexedAccessType>): any;
     visitUnionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.UnionTypeAnnotation>): any;
     visitIntersectionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.IntersectionTypeAnnotation>): any;
     visitTypeofTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TypeofTypeAnnotation>): any;
@@ -210,15 +218,17 @@ export interface Visitor<M = {}> {
     visitStringLiteral?(this: Context & M, path: NodePath<namedTypes.StringLiteral>): any;
     visitNumericLiteral?(this: Context & M, path: NodePath<namedTypes.NumericLiteral>): any;
     visitBigIntLiteral?(this: Context & M, path: NodePath<namedTypes.BigIntLiteral>): any;
+    visitDecimalLiteral?(this: Context & M, path: NodePath<namedTypes.DecimalLiteral>): any;
     visitNullLiteral?(this: Context & M, path: NodePath<namedTypes.NullLiteral>): any;
     visitBooleanLiteral?(this: Context & M, path: NodePath<namedTypes.BooleanLiteral>): any;
     visitRegExpLiteral?(this: Context & M, path: NodePath<namedTypes.RegExpLiteral>): any;
-    visitObjectMethod?(this: Context & M, path: NodePath<namedTypes.ObjectMethod>): any;
     visitClassMethod?(this: Context & M, path: NodePath<namedTypes.ClassMethod>): any;
     visitClassPrivateMethod?(this: Context & M, path: NodePath<namedTypes.ClassPrivateMethod>): any;
     visitRestProperty?(this: Context & M, path: NodePath<namedTypes.RestProperty>): any;
     visitForAwaitStatement?(this: Context & M, path: NodePath<namedTypes.ForAwaitStatement>): any;
     visitImport?(this: Context & M, path: NodePath<namedTypes.Import>): any;
+    visitV8IntrinsicIdentifier?(this: Context & M, path: NodePath<namedTypes.V8IntrinsicIdentifier>): any;
+    visitTopicReference?(this: Context & M, path: NodePath<namedTypes.TopicReference>): any;
     visitTSQualifiedName?(this: Context & M, path: NodePath<namedTypes.TSQualifiedName>): any;
     visitTSTypeReference?(this: Context & M, path: NodePath<namedTypes.TSTypeReference>): any;
     visitTSHasOptionalTypeParameters?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeParameters>): any;
@@ -237,6 +247,7 @@ export interface Visitor<M = {}> {
     visitTSUndefinedKeyword?(this: Context & M, path: NodePath<namedTypes.TSUndefinedKeyword>): any;
     visitTSUnknownKeyword?(this: Context & M, path: NodePath<namedTypes.TSUnknownKeyword>): any;
     visitTSVoidKeyword?(this: Context & M, path: NodePath<namedTypes.TSVoidKeyword>): any;
+    visitTSIntrinsicKeyword?(this: Context & M, path: NodePath<namedTypes.TSIntrinsicKeyword>): any;
     visitTSThisType?(this: Context & M, path: NodePath<namedTypes.TSThisType>): any;
     visitTSArrayType?(this: Context & M, path: NodePath<namedTypes.TSArrayType>): any;
     visitTSLiteralType?(this: Context & M, path: NodePath<namedTypes.TSLiteralType>): any;

package/lib/equiv.js

@@ -1,7 +1,7 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
 function default_1(fork) {
     var types = fork.use(types_1.default);
     var getFieldNames = types.getFieldNames;

package/lib/node-path.js

@@ -1,9 +1,9 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
-var path_1 = tslib_1.__importDefault(require("./path"));
-var scope_1 = tslib_1.__importDefault(require("./scope"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var path_1 = (0, tslib_1.__importDefault)(require("./path"));
+var scope_1 = (0, tslib_1.__importDefault)(require("./scope"));
 function nodePathPlugin(fork) {
     var types = fork.use(types_1.default);
     var n = types.namedTypes;

package/lib/path-visitor.js

@@ -1,8 +1,8 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
-var node_path_1 = tslib_1.__importDefault(require("./node-path"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
+var node_path_1 = (0, tslib_1.__importDefault)(require("./node-path"));
 var hasOwn = Object.prototype.hasOwnProperty;
 function pathVisitorPlugin(fork) {
     var types = fork.use(types_1.default);

package/lib/path.d.ts

@@ -7,9 +7,9 @@ export interface Path<V = any> {
     __childCache: object | null;
     getValueProperty(name: any): any;
     get(...names: any[]): any;
-    each(callback: any, context: any): any;
-    map(callback: any, context: any): any;
-    filter(callback: any, context: any): any;
+    each(callback: any, context?: any): any;
+    map(callback: any, context?: any): any;
+    filter(callback: any, context?: any): any;
     shift(): any;
     unshift(...args: any[]): any;
     push(...args: any[]): any;

package/lib/path.js

@@ -1,7 +1,7 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
 var Op = Object.prototype;
 var hasOwn = Op.hasOwnProperty;
 function pathPlugin(fork) {

package/lib/scope.d.ts

@@ -1,6 +1,7 @@
 import { Fork } from "../types";
+import { NodePath } from "./node-path";
 export interface Scope {
-    path: any;
+    path: NodePath;
     node: any;
     isGlobal: boolean;
     depth: number;
@@ -20,7 +21,7 @@ export interface Scope {
     getGlobalScope(): Scope;
 }
 export interface ScopeConstructor {
-    new (path: any, parentScope: any): Scope;
+    new (path: NodePath, parentScope: any): Scope;
     isEstablishedBy(node: any): any;
 }
 export default function scopePlugin(fork: Fork): ScopeConstructor;

package/lib/scope.js

@@ -1,7 +1,7 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
 var hasOwn = Object.prototype.hasOwnProperty;
 function scopePlugin(fork) {
     var types = fork.use(types_1.default);
@@ -15,7 +15,9 @@ function scopePlugin(fork) {
         if (!(this instanceof Scope)) {
             throw new Error("Scope constructor cannot be invoked without 'new'");
         }
-        ScopeType.assert(path.value);
+        if (!TypeParameterScopeType.check(path.value)) {
+            ScopeType.assert(path.value);
+        }
         var depth;
         if (parentScope) {
             if (!(parentScope instanceof Scope)) {
@@ -37,19 +39,21 @@ function scopePlugin(fork) {
             types: { value: {} },
         });
     };
-    var scopeTypes = [
-        // Program nodes introduce global scopes.
-        namedTypes.Program,
-        // Function is the supertype of FunctionExpression,
-        // FunctionDeclaration, ArrowExpression, etc.
-        namedTypes.Function,
-        // In case you didn't know, the caught parameter shadows any variable
-        // of the same name in an outer scope.
-        namedTypes.CatchClause
-    ];
-    var ScopeType = Type.or.apply(Type, scopeTypes);
+    var ScopeType = Type.or(
+    // Program nodes introduce global scopes.
+    namedTypes.Program, 
+    // Function is the supertype of FunctionExpression,
+    // FunctionDeclaration, ArrowExpression, etc.
+    namedTypes.Function, 
+    // In case you didn't know, the caught parameter shadows any variable
+    // of the same name in an outer scope.
+    namedTypes.CatchClause);
+    // These types introduce scopes that are restricted to type parameters in
+    // Flow (this doesn't apply to ECMAScript).
+    var TypeParameterScopeType = Type.or(namedTypes.Function, namedTypes.ClassDeclaration, namedTypes.ClassExpression, namedTypes.InterfaceDeclaration, namedTypes.TSInterfaceDeclaration, namedTypes.TypeAlias, namedTypes.TSTypeAliasDeclaration);
+    var FlowOrTSTypeParameterType = Type.or(namedTypes.TypeParameter, namedTypes.TSTypeParameter);
     Scope.isEstablishedBy = function (node) {
-        return ScopeType.check(node);
+        return ScopeType.check(node) || TypeParameterScopeType.check(node);
     };
     var Sp = Scope.prototype;
     // Will be overridden after an instance lazily calls scanScope.
@@ -97,6 +101,10 @@ function scopePlugin(fork) {
                 // Empty out this.bindings, just in cases.
                 delete this.bindings[name];
             }
+            for (var name in this.types) {
+                // Empty out this.types, just in cases.
+                delete this.types[name];
+            }
             scanScope(this.path, this.bindings, this.types);
             this.didScan = true;
         }
@@ -111,18 +119,24 @@ function scopePlugin(fork) {
     };
     function scanScope(path, bindings, scopeTypes) {
         var node = path.value;
-        ScopeType.assert(node);
-        if (namedTypes.CatchClause.check(node)) {
-            // A catch clause establishes a new scope but the only variable
-            // bound in that scope is the catch parameter. Any other
-            // declarations create bindings in the outer scope.
-            var param = path.get("param");
-            if (param.value) {
-                addPattern(param, bindings);
+        if (TypeParameterScopeType.check(node)) {
+            var params = path.get('typeParameters', 'params');
+            if (isArray.check(params.value)) {
+                params.each(function (childPath) {
+                    addTypeParameter(childPath, scopeTypes);
+                });
             }
         }
-        else {
-            recursiveScanScope(path, bindings, scopeTypes);
+        if (ScopeType.check(node)) {
+            if (namedTypes.CatchClause.check(node)) {
+                // A catch clause establishes a new scope but the only variable
+                // bound in that scope is the catch parameter. Any other
+                // declarations create bindings in the outer scope.
+                addPattern(path.get("param"), bindings);
+            }
+            else {
+                recursiveScanScope(path, bindings, scopeTypes);
+            }
         }
     }
     function recursiveScanScope(path, bindings, scopeTypes) {
@@ -145,6 +159,7 @@ function scopePlugin(fork) {
                 addPattern(paramPath, bindings);
             });
             recursiveScanChild(path.get("body"), bindings, scopeTypes);
+            recursiveScanScope(path.get("typeParameters"), bindings, scopeTypes);
         }
         else if ((namedTypes.TypeAlias && namedTypes.TypeAlias.check(node)) ||
             (namedTypes.InterfaceDeclaration && namedTypes.InterfaceDeclaration.check(node)) ||
@@ -201,8 +216,16 @@ function scopePlugin(fork) {
             addPattern(path.get("id"), bindings);
         }
         else if (namedTypes.ClassDeclaration &&
-            namedTypes.ClassDeclaration.check(node)) {
+            namedTypes.ClassDeclaration.check(node) &&
+            node.id !== null) {
             addPattern(path.get("id"), bindings);
+            recursiveScanScope(path.get("typeParameters"), bindings, scopeTypes);
+        }
+        else if ((namedTypes.InterfaceDeclaration &&
+            namedTypes.InterfaceDeclaration.check(node)) ||
+            (namedTypes.TSInterfaceDeclaration &&
+                namedTypes.TSInterfaceDeclaration.check(node))) {
+            addTypePattern(path.get("id"), scopeTypes);
         }
         else if (ScopeType.check(node)) {
             if (namedTypes.CatchClause.check(node) &&
@@ -249,7 +272,9 @@ function scopePlugin(fork) {
                 if (namedTypes.Pattern.check(property)) {
                     addPattern(propertyPath, bindings);
                 }
-                else if (namedTypes.Property.check(property)) {
+                else if (namedTypes.Property.check(property) ||
+                    (namedTypes.ObjectProperty &&
+                        namedTypes.ObjectProperty.check(property))) {
                     addPattern(propertyPath.get('value'), bindings);
                 }
                 else if (namedTypes.SpreadProperty &&
@@ -296,6 +321,16 @@ function scopePlugin(fork) {
             }
         }
     }
+    function addTypeParameter(parameterPath, types) {
+        var parameter = parameterPath.value;
+        FlowOrTSTypeParameterType.assert(parameter);
+        if (hasOwn.call(types, parameter.name)) {
+            types[parameter.name].push(parameterPath);
+        }
+        else {
+            types[parameter.name] = [parameterPath];
+        }
+    }
     Sp.lookup = function (name) {
         for (var scope = this; scope; scope = scope.parent)
             if (scope.declares(name))

package/lib/shared.js

@@ -1,7 +1,7 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./types"));
+var types_1 = (0, tslib_1.__importDefault)(require("./types"));
 function default_1(fork) {
     var types = fork.use(types_1.default);
     var Type = types.Type;