ast-types 0.14.1 → 0.15.2

package/def/operators/es2021.js

@@ -0,0 +1,18 @@
+"use strict";;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var es2020_1 = (0, tslib_1.__importDefault)(require("./es2020"));
+function default_1(fork) {
+    var result = fork.use(es2020_1.default);
+    // Logical assignment operators. Must run before AssignmentOperators is used.
+    // https://github.com/tc39/proposal-logical-assignment
+    result.LogicalOperators.forEach(function (op) {
+        var assignOp = op + "=";
+        if (result.AssignmentOperators.indexOf(assignOp) < 0) {
+            result.AssignmentOperators.push(assignOp);
+        }
+    });
+    return result;
+}
+exports.default = default_1;
+module.exports = exports["default"];

package/def/type-annotations.js

@@ -6,8 +6,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
 function default_1(fork) {
     var types = fork.use(types_1.default);
     var def = types.Type.def;

package/def/typescript.js

@@ -1,10 +1,10 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var babel_core_1 = tslib_1.__importDefault(require("./babel-core"));
-var type_annotations_1 = tslib_1.__importDefault(require("./type-annotations"));
-var types_1 = tslib_1.__importDefault(require("../lib/types"));
-var shared_1 = tslib_1.__importDefault(require("../lib/shared"));
+var babel_core_1 = (0, tslib_1.__importDefault)(require("./babel-core"));
+var type_annotations_1 = (0, tslib_1.__importDefault)(require("./type-annotations"));
+var types_1 = (0, tslib_1.__importDefault)(require("../lib/types"));
+var shared_1 = (0, tslib_1.__importDefault)(require("../lib/shared"));
 function default_1(fork) {
     // Since TypeScript is parsed by Babylon, include the core Babylon types
     // but omit the Flow-related types.
@@ -74,6 +74,7 @@ function default_1(fork) {
         "TSUndefinedKeyword",
         "TSUnknownKeyword",
         "TSVoidKeyword",
+        "TSIntrinsicKeyword",
         "TSThisType",
     ].forEach(function (keywordType) {
         def(keywordType)
@@ -88,6 +89,12 @@ function default_1(fork) {
         .bases("TSType")
         .build("literal")
         .field("literal", or(def("NumericLiteral"), def("StringLiteral"), def("BooleanLiteral"), def("TemplateLiteral"), def("UnaryExpression")));
+    def("TemplateLiteral")
+        // The TemplateLiteral type appears to be reused for TypeScript template
+        // literal types (instead of introducing a new TSTemplateLiteralType type),
+        // so we allow the templateLiteral.expressions array to be either all
+        // expressions or all TypeScript types.
+        .field("expressions", or([def("Expression")], [def("TSType")]));
     ["TSUnionType",
         "TSIntersectionType",
     ].forEach(function (typeName) {

package/fork.d.ts

@@ -1,5 +1,5 @@
-import { Def, Plugin } from "./types";
-export default function (defs: Def[]): {
+import { Plugin } from "./types";
+export default function (plugins: Plugin<any>[]): {
     Type: {
         or(...types: any[]): import("./lib/types").Type<any>;
         from<T>(value: any, name?: string | undefined): import("./lib/types").Type<T>;
@@ -19,6 +19,7 @@ export default function (defs: Def[]): {
         boolean: import("./lib/types").Type<boolean>;
         null: import("./lib/types").Type<null>;
         undefined: import("./lib/types").Type<undefined>;
+        BigInt: import("./lib/types").Type<BigInt>;
     };
     namedTypes: import("./gen/namedTypes").NamedTypes;
     builders: import("./gen/builders").builders;

package/fork.js

@@ -1,15 +1,15 @@
 "use strict";;
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
-var types_1 = tslib_1.__importDefault(require("./lib/types"));
-var path_visitor_1 = tslib_1.__importDefault(require("./lib/path-visitor"));
-var equiv_1 = tslib_1.__importDefault(require("./lib/equiv"));
-var path_1 = tslib_1.__importDefault(require("./lib/path"));
-var node_path_1 = tslib_1.__importDefault(require("./lib/node-path"));
-function default_1(defs) {
+var types_1 = (0, tslib_1.__importDefault)(require("./lib/types"));
+var path_visitor_1 = (0, tslib_1.__importDefault)(require("./lib/path-visitor"));
+var equiv_1 = (0, tslib_1.__importDefault)(require("./lib/equiv"));
+var path_1 = (0, tslib_1.__importDefault)(require("./lib/path"));
+var node_path_1 = (0, tslib_1.__importDefault)(require("./lib/node-path"));
+function default_1(plugins) {
     var fork = createFork();
     var types = fork.use(types_1.default);
-    defs.forEach(fork.use);
+    plugins.forEach(fork.use);
     types.finalize();
     var PathVisitor = fork.use(path_visitor_1.default);
     return {

package/gen/builders.d.ts

@@ -292,15 +292,11 @@ export interface PropertyBuilder {
     }): namedTypes.Property;
 }
 export interface LiteralBuilder {
-    (value: string | boolean | null | number | RegExp): namedTypes.Literal;
+    (value: string | boolean | null | number | RegExp | BigInt): namedTypes.Literal;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
-        value: string | boolean | null | number | RegExp;
+        value: string | boolean | null | number | RegExp | BigInt;
     }): namedTypes.Literal;
 }
 export interface SequenceExpressionBuilder {
@@ -332,12 +328,12 @@ export interface BinaryExpressionBuilder {
     }): namedTypes.BinaryExpression;
 }
 export interface AssignmentExpressionBuilder {
-    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=", left: K.PatternKind | K.MemberExpressionKind, right: K.ExpressionKind): namedTypes.AssignmentExpression;
+    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=", left: K.PatternKind | K.MemberExpressionKind, right: K.ExpressionKind): namedTypes.AssignmentExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         left: K.PatternKind | K.MemberExpressionKind;
         loc?: K.SourceLocationKind | null;
-        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=";
+        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=";
         right: K.ExpressionKind;
     }): namedTypes.AssignmentExpression;
 }
@@ -348,6 +344,7 @@ export interface MemberExpressionBuilder {
         computed?: boolean;
         loc?: K.SourceLocationKind | null;
         object: K.ExpressionKind;
+        optional?: boolean;
         property: K.IdentifierKind | K.ExpressionKind;
     }): namedTypes.MemberExpression;
 }
@@ -398,6 +395,7 @@ export interface CallExpressionBuilder {
         callee: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
+        optional?: boolean;
         typeArguments?: null | K.TypeParameterInstantiationKind;
     }): namedTypes.CallExpression;
 }
@@ -669,6 +667,7 @@ export interface ImportNamespaceSpecifierBuilder {
 export interface ImportDeclarationBuilder {
     (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type" | "typeof"): namedTypes.ImportDeclaration;
     from(params: {
+        assertions?: K.ImportAttributeKind[];
         comments?: K.CommentKind[] | null;
         importKind?: "value" | "type" | "typeof";
         loc?: K.SourceLocationKind | null;
@@ -679,6 +678,7 @@ export interface ImportDeclarationBuilder {
 export interface ExportNamedDeclarationBuilder {
     (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): namedTypes.ExportNamedDeclaration;
     from(params: {
+        assertions?: K.ImportAttributeKind[];
         comments?: K.CommentKind[] | null;
         declaration: K.DeclarationKind | null;
         loc?: K.SourceLocationKind | null;
@@ -708,6 +708,7 @@ export interface ExportDefaultDeclarationBuilder {
 export interface ExportAllDeclarationBuilder {
     (source: K.LiteralKind, exported: K.IdentifierKind | null): namedTypes.ExportAllDeclaration;
     from(params: {
+        assertions?: K.ImportAttributeKind[];
         comments?: K.CommentKind[] | null;
         exported: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
@@ -724,10 +725,10 @@ export interface TaggedTemplateExpressionBuilder {
     }): namedTypes.TaggedTemplateExpression;
 }
 export interface TemplateLiteralBuilder {
-    (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[]): namedTypes.TemplateLiteral;
+    (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[] | K.TSTypeKind[]): namedTypes.TemplateLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
-        expressions: K.ExpressionKind[];
+        expressions: K.ExpressionKind[] | K.TSTypeKind[];
         loc?: K.SourceLocationKind | null;
         quasis: K.TemplateElementKind[];
     }): namedTypes.TemplateLiteral;
@@ -789,16 +790,13 @@ export interface ImportExpressionBuilder {
         source: K.ExpressionKind;
     }): namedTypes.ImportExpression;
 }
-export interface OptionalMemberExpressionBuilder {
-    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
+export interface ChainExpressionBuilder {
+    (expression: K.ChainElementKind): namedTypes.ChainExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
-        computed?: boolean;
+        expression: K.ChainElementKind;
         loc?: K.SourceLocationKind | null;
-        object: K.ExpressionKind;
-        optional?: boolean;
-        property: K.IdentifierKind | K.ExpressionKind;
-    }): namedTypes.OptionalMemberExpression;
+    }): namedTypes.ChainExpression;
 }
 export interface OptionalCallExpressionBuilder {
     (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): namedTypes.OptionalCallExpression;
@@ -811,6 +809,111 @@ export interface OptionalCallExpressionBuilder {
         typeArguments?: null | K.TypeParameterInstantiationKind;
     }): namedTypes.OptionalCallExpression;
 }
+export interface OptionalMemberExpressionBuilder {
+    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        loc?: K.SourceLocationKind | null;
+        object: K.ExpressionKind;
+        optional?: boolean;
+        property: K.IdentifierKind | K.ExpressionKind;
+    }): namedTypes.OptionalMemberExpression;
+}
+export interface StaticBlockBuilder {
+    (body: K.StatementKind[]): namedTypes.StaticBlock;
+    from(params: {
+        body: K.StatementKind[];
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.StaticBlock;
+}
+export interface DecoratorBuilder {
+    (expression: K.ExpressionKind): namedTypes.Decorator;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Decorator;
+}
+export interface PrivateNameBuilder {
+    (id: K.IdentifierKind): namedTypes.PrivateName;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.PrivateName;
+}
+export interface ClassPrivatePropertyBuilder {
+    (key: K.PrivateNameKind, value?: K.ExpressionKind | null): namedTypes.ClassPrivateProperty;
+    from(params: {
+        access?: "public" | "private" | "protected" | undefined;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        key: K.PrivateNameKind;
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        value?: K.ExpressionKind | null;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.ClassPrivateProperty;
+}
+export interface ImportAttributeBuilder {
+    (key: K.IdentifierKind | K.LiteralKind, value: K.ExpressionKind): namedTypes.ImportAttribute;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        key: K.IdentifierKind | K.LiteralKind;
+        loc?: K.SourceLocationKind | null;
+        value: K.ExpressionKind;
+    }): namedTypes.ImportAttribute;
+}
+export interface RecordExpressionBuilder {
+    (properties: (K.ObjectPropertyKind | K.ObjectMethodKind | K.SpreadElementKind)[]): namedTypes.RecordExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        properties: (K.ObjectPropertyKind | K.ObjectMethodKind | K.SpreadElementKind)[];
+    }): namedTypes.RecordExpression;
+}
+export interface ObjectMethodBuilder {
+    (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
+    from(params: {
+        accessibility?: K.LiteralKind | null;
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        expression?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        kind: "method" | "get" | "set";
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ObjectMethod;
+}
+export interface TupleExpressionBuilder {
+    (elements: (K.ExpressionKind | K.SpreadElementKind | null)[]): namedTypes.TupleExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elements: (K.ExpressionKind | K.SpreadElementKind | null)[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TupleExpression;
+}
+export interface ModuleExpressionBuilder {
+    (body: K.ProgramKind): namedTypes.ModuleExpression;
+    from(params: {
+        body: K.ProgramKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ModuleExpression;
+}
 export interface JSXAttributeBuilder {
     (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | K.JSXElementKind | K.JSXFragmentKind | null): namedTypes.JSXAttribute;
     from(params: {
@@ -877,6 +980,7 @@ export interface JSXMemberExpressionBuilder {
         computed?: boolean;
         loc?: K.SourceLocationKind | null;
         object: K.JSXIdentifierKind | K.JSXMemberExpressionKind;
+        optional?: boolean;
         property: K.JSXIdentifierKind;
     }): namedTypes.JSXMemberExpression;
 }
@@ -901,10 +1005,6 @@ export interface JSXTextBuilder {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw?: string;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string;
     }): namedTypes.JSXText;
 }
@@ -948,36 +1048,6 @@ export interface JSXClosingFragmentBuilder {
         loc?: K.SourceLocationKind | null;
     }): namedTypes.JSXClosingFragment;
 }
-export interface DecoratorBuilder {
-    (expression: K.ExpressionKind): namedTypes.Decorator;
-    from(params: {
-        comments?: K.CommentKind[] | null;
-        expression: K.ExpressionKind;
-        loc?: K.SourceLocationKind | null;
-    }): namedTypes.Decorator;
-}
-export interface PrivateNameBuilder {
-    (id: K.IdentifierKind): namedTypes.PrivateName;
-    from(params: {
-        comments?: K.CommentKind[] | null;
-        id: K.IdentifierKind;
-        loc?: K.SourceLocationKind | null;
-    }): namedTypes.PrivateName;
-}
-export interface ClassPrivatePropertyBuilder {
-    (key: K.PrivateNameKind, value?: K.ExpressionKind | null): namedTypes.ClassPrivateProperty;
-    from(params: {
-        access?: "public" | "private" | "protected" | undefined;
-        comments?: K.CommentKind[] | null;
-        computed?: boolean;
-        key: K.PrivateNameKind;
-        loc?: K.SourceLocationKind | null;
-        static?: boolean;
-        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-        value?: K.ExpressionKind | null;
-        variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): namedTypes.ClassPrivateProperty;
-}
 export interface TypeParameterDeclarationBuilder {
     (params: K.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
     from(params: {
@@ -1309,6 +1379,25 @@ export interface MemberTypeAnnotationBuilder {
         property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;
     }): namedTypes.MemberTypeAnnotation;
 }
+export interface IndexedAccessTypeBuilder {
+    (objectType: K.FlowTypeKind, indexType: K.FlowTypeKind): namedTypes.IndexedAccessType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        indexType: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        objectType: K.FlowTypeKind;
+    }): namedTypes.IndexedAccessType;
+}
+export interface OptionalIndexedAccessTypeBuilder {
+    (objectType: K.FlowTypeKind, indexType: K.FlowTypeKind, optional: boolean): namedTypes.OptionalIndexedAccessType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        indexType: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        objectType: K.FlowTypeKind;
+        optional: boolean;
+    }): namedTypes.OptionalIndexedAccessType;
+}
 export interface UnionTypeAnnotationBuilder {
     (types: K.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
     from(params: {
@@ -1715,11 +1804,11 @@ export interface StringLiteralBuilder {
     (value: string): namedTypes.StringLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string;
     }): namedTypes.StringLiteral;
 }
@@ -1733,10 +1822,6 @@ export interface NumericLiteralBuilder {
         };
         loc?: K.SourceLocationKind | null;
         raw?: string | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: number;
     }): namedTypes.NumericLiteral;
 }
@@ -1749,22 +1834,26 @@ export interface BigIntLiteralBuilder {
             raw: string;
         };
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: string | number;
     }): namedTypes.BigIntLiteral;
 }
+export interface DecimalLiteralBuilder {
+    (value: string): namedTypes.DecimalLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
+        loc?: K.SourceLocationKind | null;
+        value: string;
+    }): namedTypes.DecimalLiteral;
+}
 export interface NullLiteralBuilder {
     (): namedTypes.NullLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value?: null;
     }): namedTypes.NullLiteral;
 }
@@ -1773,10 +1862,6 @@ export interface BooleanLiteralBuilder {
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        regex?: {
-            pattern: string;
-            flags: string;
-        } | null;
         value: boolean;
     }): namedTypes.BooleanLiteral;
 }
@@ -1784,39 +1869,20 @@ export interface RegExpLiteralBuilder {
     (pattern: string, flags: string): namedTypes.RegExpLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: RegExp | undefined;
+            raw: string;
+        };
         flags: string;
         loc?: K.SourceLocationKind | null;
         pattern: string;
         regex?: {
             pattern: string;
             flags: string;
-        } | null;
+        };
         value?: RegExp;
     }): namedTypes.RegExpLiteral;
 }
-export interface ObjectMethodBuilder {
-    (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
-    from(params: {
-        accessibility?: K.LiteralKind | null;
-        async?: boolean;
-        body: K.BlockStatementKind;
-        comments?: K.CommentKind[] | null;
-        computed?: boolean;
-        decorators?: K.DecoratorKind[] | null;
-        defaults?: (K.ExpressionKind | null)[];
-        expression?: boolean;
-        generator?: boolean;
-        id?: K.IdentifierKind | null;
-        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
-        kind: "method" | "get" | "set";
-        loc?: K.SourceLocationKind | null;
-        params: K.PatternKind[];
-        predicate?: K.FlowPredicateKind | null;
-        rest?: K.IdentifierKind | null;
-        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): namedTypes.ObjectMethod;
-}
 export interface ClassMethodBuilder {
     (kind: "get" | "set" | "method" | "constructor" | undefined, key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean, staticParam?: boolean | null): namedTypes.ClassMethod;
     from(params: {
@@ -1896,6 +1962,21 @@ export interface ImportBuilder {
         loc?: K.SourceLocationKind | null;
     }): namedTypes.Import;
 }
+export interface V8IntrinsicIdentifierBuilder {
+    (name: string): namedTypes.V8IntrinsicIdentifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: string;
+    }): namedTypes.V8IntrinsicIdentifier;
+}
+export interface TopicReferenceBuilder {
+    (): namedTypes.TopicReference;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TopicReference;
+}
 export interface TSQualifiedNameBuilder {
     (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): namedTypes.TSQualifiedName;
     from(params: {
@@ -2018,6 +2099,13 @@ export interface TSVoidKeywordBuilder {
         loc?: K.SourceLocationKind | null;
     }): namedTypes.TSVoidKeyword;
 }
+export interface TSIntrinsicKeywordBuilder {
+    (): namedTypes.TSIntrinsicKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSIntrinsicKeyword;
+}
 export interface TSThisTypeBuilder {
     (): namedTypes.TSThisType;
     from(params: {
@@ -2514,8 +2602,18 @@ export interface builders {
     spreadProperty: SpreadPropertyBuilder;
     spreadPropertyPattern: SpreadPropertyPatternBuilder;
     importExpression: ImportExpressionBuilder;
-    optionalMemberExpression: OptionalMemberExpressionBuilder;
+    chainExpression: ChainExpressionBuilder;
     optionalCallExpression: OptionalCallExpressionBuilder;
+    optionalMemberExpression: OptionalMemberExpressionBuilder;
+    staticBlock: StaticBlockBuilder;
+    decorator: DecoratorBuilder;
+    privateName: PrivateNameBuilder;
+    classPrivateProperty: ClassPrivatePropertyBuilder;
+    importAttribute: ImportAttributeBuilder;
+    recordExpression: RecordExpressionBuilder;
+    objectMethod: ObjectMethodBuilder;
+    tupleExpression: TupleExpressionBuilder;
+    moduleExpression: ModuleExpressionBuilder;
     jsxAttribute: JSXAttributeBuilder;
     jsxIdentifier: JSXIdentifierBuilder;
     jsxNamespacedName: JSXNamespacedNameBuilder;
@@ -2531,9 +2629,6 @@ export interface builders {
     jsxClosingElement: JSXClosingElementBuilder;
     jsxOpeningFragment: JSXOpeningFragmentBuilder;
     jsxClosingFragment: JSXClosingFragmentBuilder;
-    decorator: DecoratorBuilder;
-    privateName: PrivateNameBuilder;
-    classPrivateProperty: ClassPrivatePropertyBuilder;
     typeParameterDeclaration: TypeParameterDeclarationBuilder;
     tsTypeParameterDeclaration: TSTypeParameterDeclarationBuilder;
     typeParameterInstantiation: TypeParameterInstantiationBuilder;
@@ -2573,6 +2668,8 @@ export interface builders {
     qualifiedTypeIdentifier: QualifiedTypeIdentifierBuilder;
     genericTypeAnnotation: GenericTypeAnnotationBuilder;
     memberTypeAnnotation: MemberTypeAnnotationBuilder;
+    indexedAccessType: IndexedAccessTypeBuilder;
+    optionalIndexedAccessType: OptionalIndexedAccessTypeBuilder;
     unionTypeAnnotation: UnionTypeAnnotationBuilder;
     intersectionTypeAnnotation: IntersectionTypeAnnotationBuilder;
     typeofTypeAnnotation: TypeofTypeAnnotationBuilder;
@@ -2623,15 +2720,17 @@ export interface builders {
     stringLiteral: StringLiteralBuilder;
     numericLiteral: NumericLiteralBuilder;
     bigIntLiteral: BigIntLiteralBuilder;
+    decimalLiteral: DecimalLiteralBuilder;
     nullLiteral: NullLiteralBuilder;
     booleanLiteral: BooleanLiteralBuilder;
     regExpLiteral: RegExpLiteralBuilder;
-    objectMethod: ObjectMethodBuilder;
     classMethod: ClassMethodBuilder;
     classPrivateMethod: ClassPrivateMethodBuilder;
     restProperty: RestPropertyBuilder;
     forAwaitStatement: ForAwaitStatementBuilder;
     import: ImportBuilder;
+    v8IntrinsicIdentifier: V8IntrinsicIdentifierBuilder;
+    topicReference: TopicReferenceBuilder;
     tsQualifiedName: TSQualifiedNameBuilder;
     tsTypeReference: TSTypeReferenceBuilder;
     tsAsExpression: TSAsExpressionBuilder;
@@ -2648,6 +2747,7 @@ export interface builders {
     tsUndefinedKeyword: TSUndefinedKeywordBuilder;
     tsUnknownKeyword: TSUnknownKeywordBuilder;
     tsVoidKeyword: TSVoidKeywordBuilder;
+    tsIntrinsicKeyword: TSIntrinsicKeywordBuilder;
     tsThisType: TSThisTypeBuilder;
     tsArrayType: TSArrayTypeBuilder;
     tsLiteralType: TSLiteralTypeBuilder;