ast-types 0.12.2 → 0.13.1

package/gen/builders.d.ts

@@ -1,139 +1,139 @@
 import * as K from "./kinds";
-import * as N from "./nodes";
+import { namedTypes } from "./namedTypes";
 export interface FileBuilder {
-    (program: K.ProgramKind, name?: string | null): N.File;
+    (program: K.ProgramKind, name?: string | null): namedTypes.File;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name?: string | null;
         program: K.ProgramKind;
-    }): N.File;
+    }): namedTypes.File;
 }
 export interface ProgramBuilder {
-    (body: K.StatementKind[]): N.Program;
+    (body: K.StatementKind[]): namedTypes.Program;
     from(params: {
         body: K.StatementKind[];
         comments?: K.CommentKind[] | null;
         directives?: K.DirectiveKind[];
         interpreter?: K.InterpreterDirectiveKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.Program;
+    }): namedTypes.Program;
 }
 export interface IdentifierBuilder {
-    (name: string): N.Identifier;
+    (name: string): namedTypes.Identifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: string;
         optional?: boolean;
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-    }): N.Identifier;
+    }): namedTypes.Identifier;
 }
 export interface BlockStatementBuilder {
-    (body: K.StatementKind[]): N.BlockStatement;
+    (body: K.StatementKind[]): namedTypes.BlockStatement;
     from(params: {
         body: K.StatementKind[];
         comments?: K.CommentKind[] | null;
         directives?: K.DirectiveKind[];
         loc?: K.SourceLocationKind | null;
-    }): N.BlockStatement;
+    }): namedTypes.BlockStatement;
 }
 export interface EmptyStatementBuilder {
-    (): N.EmptyStatement;
+    (): namedTypes.EmptyStatement;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.EmptyStatement;
+    }): namedTypes.EmptyStatement;
 }
 export interface ExpressionStatementBuilder {
-    (expression: K.ExpressionKind): N.ExpressionStatement;
+    (expression: K.ExpressionKind): namedTypes.ExpressionStatement;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ExpressionStatement;
+    }): namedTypes.ExpressionStatement;
 }
 export interface IfStatementBuilder {
-    (test: K.ExpressionKind, consequent: K.StatementKind, alternate?: K.StatementKind | null): N.IfStatement;
+    (test: K.ExpressionKind, consequent: K.StatementKind, alternate?: K.StatementKind | null): namedTypes.IfStatement;
     from(params: {
         alternate?: K.StatementKind | null;
         comments?: K.CommentKind[] | null;
         consequent: K.StatementKind;
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind;
-    }): N.IfStatement;
+    }): namedTypes.IfStatement;
 }
 export interface LabeledStatementBuilder {
-    (label: K.IdentifierKind, body: K.StatementKind): N.LabeledStatement;
+    (label: K.IdentifierKind, body: K.StatementKind): namedTypes.LabeledStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         label: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.LabeledStatement;
+    }): namedTypes.LabeledStatement;
 }
 export interface BreakStatementBuilder {
-    (label?: K.IdentifierKind | null): N.BreakStatement;
+    (label?: K.IdentifierKind | null): namedTypes.BreakStatement;
     from(params: {
         comments?: K.CommentKind[] | null;
         label?: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.BreakStatement;
+    }): namedTypes.BreakStatement;
 }
 export interface ContinueStatementBuilder {
-    (label?: K.IdentifierKind | null): N.ContinueStatement;
+    (label?: K.IdentifierKind | null): namedTypes.ContinueStatement;
     from(params: {
         comments?: K.CommentKind[] | null;
         label?: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ContinueStatement;
+    }): namedTypes.ContinueStatement;
 }
 export interface WithStatementBuilder {
-    (object: K.ExpressionKind, body: K.StatementKind): N.WithStatement;
+    (object: K.ExpressionKind, body: K.StatementKind): namedTypes.WithStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         object: K.ExpressionKind;
-    }): N.WithStatement;
+    }): namedTypes.WithStatement;
 }
 export interface SwitchStatementBuilder {
-    (discriminant: K.ExpressionKind, cases: K.SwitchCaseKind[], lexical?: boolean): N.SwitchStatement;
+    (discriminant: K.ExpressionKind, cases: K.SwitchCaseKind[], lexical?: boolean): namedTypes.SwitchStatement;
     from(params: {
         cases: K.SwitchCaseKind[];
         comments?: K.CommentKind[] | null;
         discriminant: K.ExpressionKind;
         lexical?: boolean;
         loc?: K.SourceLocationKind | null;
-    }): N.SwitchStatement;
+    }): namedTypes.SwitchStatement;
 }
 export interface SwitchCaseBuilder {
-    (test: K.ExpressionKind | null, consequent: K.StatementKind[]): N.SwitchCase;
+    (test: K.ExpressionKind | null, consequent: K.StatementKind[]): namedTypes.SwitchCase;
     from(params: {
         comments?: K.CommentKind[] | null;
         consequent: K.StatementKind[];
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind | null;
-    }): N.SwitchCase;
+    }): namedTypes.SwitchCase;
 }
 export interface ReturnStatementBuilder {
-    (argument: K.ExpressionKind | null): N.ReturnStatement;
+    (argument: K.ExpressionKind | null): namedTypes.ReturnStatement;
     from(params: {
         argument: K.ExpressionKind | null;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ReturnStatement;
+    }): namedTypes.ReturnStatement;
 }
 export interface ThrowStatementBuilder {
-    (argument: K.ExpressionKind): N.ThrowStatement;
+    (argument: K.ExpressionKind): namedTypes.ThrowStatement;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ThrowStatement;
+    }): namedTypes.ThrowStatement;
 }
 export interface TryStatementBuilder {
-    (block: K.BlockStatementKind, handler?: K.CatchClauseKind | null, finalizer?: K.BlockStatementKind | null): N.TryStatement;
+    (block: K.BlockStatementKind, handler?: K.CatchClauseKind | null, finalizer?: K.BlockStatementKind | null): namedTypes.TryStatement;
     from(params: {
         block: K.BlockStatementKind;
         comments?: K.CommentKind[] | null;
@@ -142,38 +142,38 @@ export interface TryStatementBuilder {
         handler?: K.CatchClauseKind | null;
         handlers?: K.CatchClauseKind[];
         loc?: K.SourceLocationKind | null;
-    }): N.TryStatement;
+    }): namedTypes.TryStatement;
 }
 export interface CatchClauseBuilder {
-    (param: K.PatternKind | null | undefined, guard: K.ExpressionKind | null | undefined, body: K.BlockStatementKind): N.CatchClause;
+    (param: K.PatternKind | null | undefined, guard: K.ExpressionKind | null | undefined, body: K.BlockStatementKind): namedTypes.CatchClause;
     from(params: {
         body: K.BlockStatementKind;
         comments?: K.CommentKind[] | null;
         guard?: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
         param?: K.PatternKind | null;
-    }): N.CatchClause;
+    }): namedTypes.CatchClause;
 }
 export interface WhileStatementBuilder {
-    (test: K.ExpressionKind, body: K.StatementKind): N.WhileStatement;
+    (test: K.ExpressionKind, body: K.StatementKind): namedTypes.WhileStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind;
-    }): N.WhileStatement;
+    }): namedTypes.WhileStatement;
 }
 export interface DoWhileStatementBuilder {
-    (body: K.StatementKind, test: K.ExpressionKind): N.DoWhileStatement;
+    (body: K.StatementKind, test: K.ExpressionKind): namedTypes.DoWhileStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind;
-    }): N.DoWhileStatement;
+    }): namedTypes.DoWhileStatement;
 }
 export interface ForStatementBuilder {
-    (init: K.VariableDeclarationKind | K.ExpressionKind | null, test: K.ExpressionKind | null, update: K.ExpressionKind | null, body: K.StatementKind): N.ForStatement;
+    (init: K.VariableDeclarationKind | K.ExpressionKind | null, test: K.ExpressionKind | null, update: K.ExpressionKind | null, body: K.StatementKind): namedTypes.ForStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
@@ -181,36 +181,36 @@ export interface ForStatementBuilder {
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind | null;
         update: K.ExpressionKind | null;
-    }): N.ForStatement;
+    }): namedTypes.ForStatement;
 }
 export interface VariableDeclarationBuilder {
-    (kind: "var" | "let" | "const", declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[]): N.VariableDeclaration;
+    (kind: "var" | "let" | "const", declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[]): namedTypes.VariableDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[];
         kind: "var" | "let" | "const";
         loc?: K.SourceLocationKind | null;
-    }): N.VariableDeclaration;
+    }): namedTypes.VariableDeclaration;
 }
 export interface ForInStatementBuilder {
-    (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): N.ForInStatement;
+    (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForInStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         left: K.VariableDeclarationKind | K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         right: K.ExpressionKind;
-    }): N.ForInStatement;
+    }): namedTypes.ForInStatement;
 }
 export interface DebuggerStatementBuilder {
-    (): N.DebuggerStatement;
+    (): namedTypes.DebuggerStatement;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.DebuggerStatement;
+    }): namedTypes.DebuggerStatement;
 }
 export interface FunctionDeclarationBuilder {
-    (id: K.IdentifierKind, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): N.FunctionDeclaration;
+    (id: K.IdentifierKind, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionDeclaration;
     from(params: {
         async?: boolean;
         body: K.BlockStatementKind;
@@ -224,10 +224,10 @@ export interface FunctionDeclarationBuilder {
         rest?: K.IdentifierKind | null;
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.FunctionDeclaration;
+    }): namedTypes.FunctionDeclaration;
 }
 export interface FunctionExpressionBuilder {
-    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): N.FunctionExpression;
+    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionExpression;
     from(params: {
         async?: boolean;
         body: K.BlockStatementKind;
@@ -241,42 +241,42 @@ export interface FunctionExpressionBuilder {
         rest?: K.IdentifierKind | null;
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.FunctionExpression;
+    }): namedTypes.FunctionExpression;
 }
 export interface VariableDeclaratorBuilder {
-    (id: K.PatternKind, init?: K.ExpressionKind | null): N.VariableDeclarator;
+    (id: K.PatternKind, init?: K.ExpressionKind | null): namedTypes.VariableDeclarator;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.PatternKind;
         init?: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.VariableDeclarator;
+    }): namedTypes.VariableDeclarator;
 }
 export interface ThisExpressionBuilder {
-    (): N.ThisExpression;
+    (): namedTypes.ThisExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ThisExpression;
+    }): namedTypes.ThisExpression;
 }
 export interface ArrayExpressionBuilder {
-    (elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[]): N.ArrayExpression;
+    (elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[]): namedTypes.ArrayExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[];
         loc?: K.SourceLocationKind | null;
-    }): N.ArrayExpression;
+    }): namedTypes.ArrayExpression;
 }
 export interface ObjectExpressionBuilder {
-    (properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[]): N.ObjectExpression;
+    (properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[]): namedTypes.ObjectExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[];
-    }): N.ObjectExpression;
+    }): namedTypes.ObjectExpression;
 }
 export interface PropertyBuilder {
-    (kind: "init" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): N.Property;
+    (kind: "init" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): namedTypes.Property;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
@@ -287,10 +287,10 @@ export interface PropertyBuilder {
         method?: boolean;
         shorthand?: boolean;
         value: K.ExpressionKind | K.PatternKind;
-    }): N.Property;
+    }): namedTypes.Property;
 }
 export interface LiteralBuilder {
-    (value: string | boolean | null | number | RegExp): N.Literal;
+    (value: string | boolean | null | number | RegExp): namedTypes.Literal;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -299,139 +299,139 @@ export interface LiteralBuilder {
             flags: string;
         } | null;
         value: string | boolean | null | number | RegExp;
-    }): N.Literal;
+    }): namedTypes.Literal;
 }
 export interface SequenceExpressionBuilder {
-    (expressions: K.ExpressionKind[]): N.SequenceExpression;
+    (expressions: K.ExpressionKind[]): namedTypes.SequenceExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         expressions: K.ExpressionKind[];
         loc?: K.SourceLocationKind | null;
-    }): N.SequenceExpression;
+    }): namedTypes.SequenceExpression;
 }
 export interface UnaryExpressionBuilder {
-    (operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete", argument: K.ExpressionKind, prefix?: boolean): N.UnaryExpression;
+    (operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete", argument: K.ExpressionKind, prefix?: boolean): namedTypes.UnaryExpression;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
         prefix?: boolean;
-    }): N.UnaryExpression;
+    }): namedTypes.UnaryExpression;
 }
 export interface BinaryExpressionBuilder {
-    (operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof", left: K.ExpressionKind, right: K.ExpressionKind): N.BinaryExpression;
+    (operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof", left: K.ExpressionKind, right: K.ExpressionKind): namedTypes.BinaryExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         left: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof";
         right: K.ExpressionKind;
-    }): N.BinaryExpression;
+    }): namedTypes.BinaryExpression;
 }
 export interface AssignmentExpressionBuilder {
-    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=", left: K.PatternKind, right: K.ExpressionKind): N.AssignmentExpression;
+    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=", left: K.PatternKind | K.MemberExpressionKind, right: K.ExpressionKind): namedTypes.AssignmentExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
-        left: K.PatternKind;
+        left: K.PatternKind | K.MemberExpressionKind;
         loc?: K.SourceLocationKind | null;
         operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
         right: K.ExpressionKind;
-    }): N.AssignmentExpression;
+    }): namedTypes.AssignmentExpression;
+}
+export interface MemberExpressionBuilder {
+    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean): namedTypes.MemberExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        loc?: K.SourceLocationKind | null;
+        object: K.ExpressionKind;
+        property: K.IdentifierKind | K.ExpressionKind;
+    }): namedTypes.MemberExpression;
 }
 export interface UpdateExpressionBuilder {
-    (operator: "++" | "--", argument: K.ExpressionKind, prefix: boolean): N.UpdateExpression;
+    (operator: "++" | "--", argument: K.ExpressionKind, prefix: boolean): namedTypes.UpdateExpression;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         operator: "++" | "--";
         prefix: boolean;
-    }): N.UpdateExpression;
+    }): namedTypes.UpdateExpression;
 }
 export interface LogicalExpressionBuilder {
-    (operator: "||" | "&&" | "??", left: K.ExpressionKind, right: K.ExpressionKind): N.LogicalExpression;
+    (operator: "||" | "&&" | "??", left: K.ExpressionKind, right: K.ExpressionKind): namedTypes.LogicalExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         left: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         operator: "||" | "&&" | "??";
         right: K.ExpressionKind;
-    }): N.LogicalExpression;
+    }): namedTypes.LogicalExpression;
 }
 export interface ConditionalExpressionBuilder {
-    (test: K.ExpressionKind, consequent: K.ExpressionKind, alternate: K.ExpressionKind): N.ConditionalExpression;
+    (test: K.ExpressionKind, consequent: K.ExpressionKind, alternate: K.ExpressionKind): namedTypes.ConditionalExpression;
     from(params: {
         alternate: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         consequent: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         test: K.ExpressionKind;
-    }): N.ConditionalExpression;
+    }): namedTypes.ConditionalExpression;
 }
 export interface NewExpressionBuilder {
-    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): N.NewExpression;
+    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): namedTypes.NewExpression;
     from(params: {
         arguments: (K.ExpressionKind | K.SpreadElementKind)[];
         callee: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.NewExpression;
+    }): namedTypes.NewExpression;
 }
 export interface CallExpressionBuilder {
-    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): N.CallExpression;
+    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): namedTypes.CallExpression;
     from(params: {
         arguments: (K.ExpressionKind | K.SpreadElementKind)[];
         callee: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.CallExpression;
-}
-export interface MemberExpressionBuilder {
-    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean): N.MemberExpression;
-    from(params: {
-        comments?: K.CommentKind[] | null;
-        computed?: boolean;
-        loc?: K.SourceLocationKind | null;
-        object: K.ExpressionKind;
-        property: K.IdentifierKind | K.ExpressionKind;
-    }): N.MemberExpression;
+    }): namedTypes.CallExpression;
 }
 export interface RestElementBuilder {
-    (argument: K.PatternKind): N.RestElement;
+    (argument: K.PatternKind): namedTypes.RestElement;
     from(params: {
         argument: K.PatternKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-    }): N.RestElement;
+    }): namedTypes.RestElement;
 }
 export interface TypeAnnotationBuilder {
-    (typeAnnotation: K.FlowTypeKind): N.TypeAnnotation;
+    (typeAnnotation: K.FlowTypeKind): namedTypes.TypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.FlowTypeKind;
-    }): N.TypeAnnotation;
+    }): namedTypes.TypeAnnotation;
 }
 export interface TSTypeAnnotationBuilder {
-    (typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind): N.TSTypeAnnotation;
+    (typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind): namedTypes.TSTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind;
-    }): N.TSTypeAnnotation;
+    }): namedTypes.TSTypeAnnotation;
 }
 export interface SpreadElementPatternBuilder {
-    (argument: K.PatternKind): N.SpreadElementPattern;
+    (argument: K.PatternKind): namedTypes.SpreadElementPattern;
     from(params: {
         argument: K.PatternKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.SpreadElementPattern;
+    }): namedTypes.SpreadElementPattern;
 }
 export interface ArrowFunctionExpressionBuilder {
-    (params: K.PatternKind[], body: K.BlockStatementKind | K.ExpressionKind, expression?: boolean): N.ArrowFunctionExpression;
+    (params: K.PatternKind[], body: K.BlockStatementKind | K.ExpressionKind, expression?: boolean): namedTypes.ArrowFunctionExpression;
     from(params: {
         async?: boolean;
         body: K.BlockStatementKind | K.ExpressionKind;
@@ -445,59 +445,59 @@ export interface ArrowFunctionExpressionBuilder {
         rest?: K.IdentifierKind | null;
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ArrowFunctionExpression;
+    }): namedTypes.ArrowFunctionExpression;
 }
 export interface ForOfStatementBuilder {
-    (left: K.VariableDeclarationKind | K.PatternKind, right: K.ExpressionKind, body: K.StatementKind): N.ForOfStatement;
+    (left: K.VariableDeclarationKind | K.PatternKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForOfStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         left: K.VariableDeclarationKind | K.PatternKind;
         loc?: K.SourceLocationKind | null;
         right: K.ExpressionKind;
-    }): N.ForOfStatement;
+    }): namedTypes.ForOfStatement;
 }
 export interface YieldExpressionBuilder {
-    (argument: K.ExpressionKind | null, delegate?: boolean): N.YieldExpression;
+    (argument: K.ExpressionKind | null, delegate?: boolean): namedTypes.YieldExpression;
     from(params: {
         argument: K.ExpressionKind | null;
         comments?: K.CommentKind[] | null;
         delegate?: boolean;
         loc?: K.SourceLocationKind | null;
-    }): N.YieldExpression;
+    }): namedTypes.YieldExpression;
 }
 export interface GeneratorExpressionBuilder {
-    (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): N.GeneratorExpression;
+    (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): namedTypes.GeneratorExpression;
     from(params: {
         blocks: K.ComprehensionBlockKind[];
         body: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         filter: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.GeneratorExpression;
+    }): namedTypes.GeneratorExpression;
 }
 export interface ComprehensionBlockBuilder {
-    (left: K.PatternKind, right: K.ExpressionKind, each: boolean): N.ComprehensionBlock;
+    (left: K.PatternKind, right: K.ExpressionKind, each: boolean): namedTypes.ComprehensionBlock;
     from(params: {
         comments?: K.CommentKind[] | null;
         each: boolean;
         left: K.PatternKind;
         loc?: K.SourceLocationKind | null;
         right: K.ExpressionKind;
-    }): N.ComprehensionBlock;
+    }): namedTypes.ComprehensionBlock;
 }
 export interface ComprehensionExpressionBuilder {
-    (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): N.ComprehensionExpression;
+    (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): namedTypes.ComprehensionExpression;
     from(params: {
         blocks: K.ComprehensionBlockKind[];
         body: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         filter: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ComprehensionExpression;
+    }): namedTypes.ComprehensionExpression;
 }
 export interface ObjectPropertyBuilder {
-    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): N.ObjectProperty;
+    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): namedTypes.ObjectProperty;
     from(params: {
         accessibility?: K.LiteralKind | null;
         comments?: K.CommentKind[] | null;
@@ -506,38 +506,38 @@ export interface ObjectPropertyBuilder {
         loc?: K.SourceLocationKind | null;
         shorthand?: boolean;
         value: K.ExpressionKind | K.PatternKind;
-    }): N.ObjectProperty;
+    }): namedTypes.ObjectProperty;
 }
 export interface PropertyPatternBuilder {
-    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, pattern: K.PatternKind): N.PropertyPattern;
+    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, pattern: K.PatternKind): namedTypes.PropertyPattern;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
         key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         pattern: K.PatternKind;
-    }): N.PropertyPattern;
+    }): namedTypes.PropertyPattern;
 }
 export interface ObjectPatternBuilder {
-    (properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[]): N.ObjectPattern;
+    (properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[]): namedTypes.ObjectPattern;
     from(params: {
         comments?: K.CommentKind[] | null;
         decorators?: K.DecoratorKind[] | null;
         loc?: K.SourceLocationKind | null;
         properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[];
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-    }): N.ObjectPattern;
+    }): namedTypes.ObjectPattern;
 }
 export interface ArrayPatternBuilder {
-    (elements: (K.PatternKind | K.SpreadElementKind | null)[]): N.ArrayPattern;
+    (elements: (K.PatternKind | K.SpreadElementKind | null)[]): namedTypes.ArrayPattern;
     from(params: {
         comments?: K.CommentKind[] | null;
         elements: (K.PatternKind | K.SpreadElementKind | null)[];
         loc?: K.SourceLocationKind | null;
-    }): N.ArrayPattern;
+    }): namedTypes.ArrayPattern;
 }
 export interface MethodDefinitionBuilder {
-    (kind: "constructor" | "method" | "get" | "set", key: K.ExpressionKind, value: K.FunctionKind, staticParam?: boolean): N.MethodDefinition;
+    (kind: "constructor" | "method" | "get" | "set", key: K.ExpressionKind, value: K.FunctionKind, staticParam?: boolean): namedTypes.MethodDefinition;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
@@ -547,36 +547,37 @@ export interface MethodDefinitionBuilder {
         loc?: K.SourceLocationKind | null;
         static?: boolean;
         value: K.FunctionKind;
-    }): N.MethodDefinition;
+    }): namedTypes.MethodDefinition;
 }
 export interface SpreadElementBuilder {
-    (argument: K.ExpressionKind): N.SpreadElement;
+    (argument: K.ExpressionKind): namedTypes.SpreadElement;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.SpreadElement;
+    }): namedTypes.SpreadElement;
 }
 export interface AssignmentPatternBuilder {
-    (left: K.PatternKind, right: K.ExpressionKind): N.AssignmentPattern;
+    (left: K.PatternKind, right: K.ExpressionKind): namedTypes.AssignmentPattern;
     from(params: {
         comments?: K.CommentKind[] | null;
         left: K.PatternKind;
         loc?: K.SourceLocationKind | null;
         right: K.ExpressionKind;
-    }): N.AssignmentPattern;
+    }): namedTypes.AssignmentPattern;
 }
 export interface ClassPropertyDefinitionBuilder {
-    (definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind): N.ClassPropertyDefinition;
+    (definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind): namedTypes.ClassPropertyDefinition;
     from(params: {
         comments?: K.CommentKind[] | null;
         definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ClassPropertyDefinition;
+    }): namedTypes.ClassPropertyDefinition;
 }
 export interface ClassPropertyBuilder {
-    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | null, typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null, staticParam?: boolean): N.ClassProperty;
+    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | null, typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null, staticParam?: boolean): namedTypes.ClassProperty;
     from(params: {
+        access?: "public" | "private" | "protected" | undefined;
         comments?: K.CommentKind[] | null;
         computed?: boolean;
         key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
@@ -585,18 +586,18 @@ export interface ClassPropertyBuilder {
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         value: K.ExpressionKind | null;
         variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): N.ClassProperty;
+    }): namedTypes.ClassProperty;
 }
 export interface ClassBodyBuilder {
-    (body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.ClassBody;
+    (body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.ClassBody;
     from(params: {
         body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ClassBody;
+    }): namedTypes.ClassBody;
 }
 export interface ClassDeclarationBuilder {
-    (id: K.IdentifierKind | null, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): N.ClassDeclaration;
+    (id: K.IdentifierKind | null, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassDeclaration;
     from(params: {
         body: K.ClassBodyKind;
         comments?: K.CommentKind[] | null;
@@ -606,10 +607,10 @@ export interface ClassDeclarationBuilder {
         superClass?: K.ExpressionKind | null;
         superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ClassDeclaration;
+    }): namedTypes.ClassDeclaration;
 }
 export interface ClassExpressionBuilder {
-    (id: K.IdentifierKind | null | undefined, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): N.ClassExpression;
+    (id: K.IdentifierKind | null | undefined, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassExpression;
     from(params: {
         body: K.ClassBodyKind;
         comments?: K.CommentKind[] | null;
@@ -619,10 +620,10 @@ export interface ClassExpressionBuilder {
         superClass?: K.ExpressionKind | null;
         superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ClassExpression;
+    }): namedTypes.ClassExpression;
 }
 export interface ImportSpecifierBuilder {
-    (imported: K.IdentifierKind, local?: K.IdentifierKind | null): N.ImportSpecifier;
+    (imported: K.IdentifierKind, local?: K.IdentifierKind | null): namedTypes.ImportSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         id?: K.IdentifierKind | null;
@@ -630,61 +631,61 @@ export interface ImportSpecifierBuilder {
         loc?: K.SourceLocationKind | null;
         local?: K.IdentifierKind | null;
         name?: K.IdentifierKind | null;
-    }): N.ImportSpecifier;
+    }): namedTypes.ImportSpecifier;
 }
 export interface ImportNamespaceSpecifierBuilder {
-    (local?: K.IdentifierKind | null): N.ImportNamespaceSpecifier;
+    (local?: K.IdentifierKind | null): namedTypes.ImportNamespaceSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         id?: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
         local?: K.IdentifierKind | null;
         name?: K.IdentifierKind | null;
-    }): N.ImportNamespaceSpecifier;
+    }): namedTypes.ImportNamespaceSpecifier;
 }
 export interface ImportDefaultSpecifierBuilder {
-    (local?: K.IdentifierKind | null): N.ImportDefaultSpecifier;
+    (local?: K.IdentifierKind | null): namedTypes.ImportDefaultSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         id?: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
         local?: K.IdentifierKind | null;
         name?: K.IdentifierKind | null;
-    }): N.ImportDefaultSpecifier;
+    }): namedTypes.ImportDefaultSpecifier;
 }
 export interface ImportDeclarationBuilder {
-    (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type"): N.ImportDeclaration;
+    (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type"): namedTypes.ImportDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         importKind?: "value" | "type";
         loc?: K.SourceLocationKind | null;
         source: K.LiteralKind;
         specifiers?: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[];
-    }): N.ImportDeclaration;
+    }): namedTypes.ImportDeclaration;
 }
 export interface TaggedTemplateExpressionBuilder {
-    (tag: K.ExpressionKind, quasi: K.TemplateLiteralKind): N.TaggedTemplateExpression;
+    (tag: K.ExpressionKind, quasi: K.TemplateLiteralKind): namedTypes.TaggedTemplateExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         quasi: K.TemplateLiteralKind;
         tag: K.ExpressionKind;
-    }): N.TaggedTemplateExpression;
+    }): namedTypes.TaggedTemplateExpression;
 }
 export interface TemplateLiteralBuilder {
-    (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[]): N.TemplateLiteral;
+    (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[]): namedTypes.TemplateLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         expressions: K.ExpressionKind[];
         loc?: K.SourceLocationKind | null;
         quasis: K.TemplateElementKind[];
-    }): N.TemplateLiteral;
+    }): namedTypes.TemplateLiteral;
 }
 export interface TemplateElementBuilder {
     (value: {
         cooked: string;
         raw: string;
-    }, tail: boolean): N.TemplateElement;
+    }, tail: boolean): namedTypes.TemplateElement;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -693,89 +694,89 @@ export interface TemplateElementBuilder {
             cooked: string;
             raw: string;
         };
-    }): N.TemplateElement;
+    }): namedTypes.TemplateElement;
 }
 export interface SpreadPropertyBuilder {
-    (argument: K.ExpressionKind): N.SpreadProperty;
+    (argument: K.ExpressionKind): namedTypes.SpreadProperty;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.SpreadProperty;
+    }): namedTypes.SpreadProperty;
 }
 export interface SpreadPropertyPatternBuilder {
-    (argument: K.PatternKind): N.SpreadPropertyPattern;
+    (argument: K.PatternKind): namedTypes.SpreadPropertyPattern;
     from(params: {
         argument: K.PatternKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.SpreadPropertyPattern;
+    }): namedTypes.SpreadPropertyPattern;
 }
 export interface AwaitExpressionBuilder {
-    (argument: K.ExpressionKind | null, all?: boolean): N.AwaitExpression;
+    (argument: K.ExpressionKind | null, all?: boolean): namedTypes.AwaitExpression;
     from(params: {
         all?: boolean;
         argument: K.ExpressionKind | null;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.AwaitExpression;
+    }): namedTypes.AwaitExpression;
 }
 export interface JSXAttributeBuilder {
-    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): N.JSXAttribute;
+    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): namedTypes.JSXAttribute;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;
         value?: K.LiteralKind | K.JSXExpressionContainerKind | null;
-    }): N.JSXAttribute;
+    }): namedTypes.JSXAttribute;
 }
 export interface JSXIdentifierBuilder {
-    (name: string): N.JSXIdentifier;
+    (name: string): namedTypes.JSXIdentifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: string;
         optional?: boolean;
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-    }): N.JSXIdentifier;
+    }): namedTypes.JSXIdentifier;
 }
 export interface JSXNamespacedNameBuilder {
-    (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): N.JSXNamespacedName;
+    (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): namedTypes.JSXNamespacedName;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: K.JSXIdentifierKind;
         namespace: K.JSXIdentifierKind;
-    }): N.JSXNamespacedName;
+    }): namedTypes.JSXNamespacedName;
 }
 export interface JSXExpressionContainerBuilder {
-    (expression: K.ExpressionKind): N.JSXExpressionContainer;
+    (expression: K.ExpressionKind): namedTypes.JSXExpressionContainer;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXExpressionContainer;
+    }): namedTypes.JSXExpressionContainer;
 }
 export interface JSXMemberExpressionBuilder {
-    (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): N.JSXMemberExpression;
+    (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): namedTypes.JSXMemberExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
         loc?: K.SourceLocationKind | null;
         object: K.JSXIdentifierKind | K.JSXMemberExpressionKind;
         property: K.JSXIdentifierKind;
-    }): N.JSXMemberExpression;
+    }): namedTypes.JSXMemberExpression;
 }
 export interface JSXSpreadAttributeBuilder {
-    (argument: K.ExpressionKind): N.JSXSpreadAttribute;
+    (argument: K.ExpressionKind): namedTypes.JSXSpreadAttribute;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXSpreadAttribute;
+    }): namedTypes.JSXSpreadAttribute;
 }
 export interface JSXElementBuilder {
-    (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXElement;
+    (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXElement;
     from(params: {
         attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
         children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
@@ -785,38 +786,38 @@ export interface JSXElementBuilder {
         name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
         openingElement: K.JSXOpeningElementKind;
         selfClosing?: boolean;
-    }): N.JSXElement;
+    }): namedTypes.JSXElement;
 }
 export interface JSXOpeningElementBuilder {
-    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): N.JSXOpeningElement;
+    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): namedTypes.JSXOpeningElement;
     from(params: {
         attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
         selfClosing?: boolean;
-    }): N.JSXOpeningElement;
+    }): namedTypes.JSXOpeningElement;
 }
 export interface JSXClosingElementBuilder {
-    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): N.JSXClosingElement;
+    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): namedTypes.JSXClosingElement;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
-    }): N.JSXClosingElement;
+    }): namedTypes.JSXClosingElement;
 }
 export interface JSXFragmentBuilder {
-    (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXFragment;
+    (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXFragment;
     from(params: {
         children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
         closingElement: K.JSXClosingFragmentKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         openingElement: K.JSXOpeningFragmentKind;
-    }): N.JSXFragment;
+    }): namedTypes.JSXFragment;
 }
 export interface JSXTextBuilder {
-    (value: string): N.JSXText;
+    (value: string): namedTypes.JSXText;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -825,218 +826,218 @@ export interface JSXTextBuilder {
             flags: string;
         } | null;
         value: string;
-    }): N.JSXText;
+    }): namedTypes.JSXText;
 }
 export interface JSXOpeningFragmentBuilder {
-    (): N.JSXOpeningFragment;
+    (): namedTypes.JSXOpeningFragment;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXOpeningFragment;
+    }): namedTypes.JSXOpeningFragment;
 }
 export interface JSXClosingFragmentBuilder {
-    (): N.JSXClosingFragment;
+    (): namedTypes.JSXClosingFragment;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXClosingFragment;
+    }): namedTypes.JSXClosingFragment;
 }
 export interface JSXEmptyExpressionBuilder {
-    (): N.JSXEmptyExpression;
+    (): namedTypes.JSXEmptyExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXEmptyExpression;
+    }): namedTypes.JSXEmptyExpression;
 }
 export interface JSXSpreadChildBuilder {
-    (expression: K.ExpressionKind): N.JSXSpreadChild;
+    (expression: K.ExpressionKind): namedTypes.JSXSpreadChild;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.JSXSpreadChild;
+    }): namedTypes.JSXSpreadChild;
 }
 export interface TypeParameterDeclarationBuilder {
-    (params: K.TypeParameterKind[]): N.TypeParameterDeclaration;
+    (params: K.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         params: K.TypeParameterKind[];
-    }): N.TypeParameterDeclaration;
+    }): namedTypes.TypeParameterDeclaration;
 }
 export interface TSTypeParameterDeclarationBuilder {
-    (params: K.TSTypeParameterKind[]): N.TSTypeParameterDeclaration;
+    (params: K.TSTypeParameterKind[]): namedTypes.TSTypeParameterDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         params: K.TSTypeParameterKind[];
-    }): N.TSTypeParameterDeclaration;
+    }): namedTypes.TSTypeParameterDeclaration;
 }
 export interface TypeParameterInstantiationBuilder {
-    (params: K.FlowTypeKind[]): N.TypeParameterInstantiation;
+    (params: K.FlowTypeKind[]): namedTypes.TypeParameterInstantiation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         params: K.FlowTypeKind[];
-    }): N.TypeParameterInstantiation;
+    }): namedTypes.TypeParameterInstantiation;
 }
 export interface TSTypeParameterInstantiationBuilder {
-    (params: K.TSTypeKind[]): N.TSTypeParameterInstantiation;
+    (params: K.TSTypeKind[]): namedTypes.TSTypeParameterInstantiation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         params: K.TSTypeKind[];
-    }): N.TSTypeParameterInstantiation;
+    }): namedTypes.TSTypeParameterInstantiation;
 }
 export interface ClassImplementsBuilder {
-    (id: K.IdentifierKind): N.ClassImplements;
+    (id: K.IdentifierKind): namedTypes.ClassImplements;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         superClass?: K.ExpressionKind | null;
         typeParameters?: K.TypeParameterInstantiationKind | null;
-    }): N.ClassImplements;
+    }): namedTypes.ClassImplements;
 }
 export interface TSExpressionWithTypeArgumentsBuilder {
-    (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSExpressionWithTypeArguments;
+    (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSExpressionWithTypeArguments;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.IdentifierKind | K.TSQualifiedNameKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TSTypeParameterInstantiationKind | null;
-    }): N.TSExpressionWithTypeArguments;
+    }): namedTypes.TSExpressionWithTypeArguments;
 }
 export interface AnyTypeAnnotationBuilder {
-    (): N.AnyTypeAnnotation;
+    (): namedTypes.AnyTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.AnyTypeAnnotation;
+    }): namedTypes.AnyTypeAnnotation;
 }
 export interface EmptyTypeAnnotationBuilder {
-    (): N.EmptyTypeAnnotation;
+    (): namedTypes.EmptyTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.EmptyTypeAnnotation;
+    }): namedTypes.EmptyTypeAnnotation;
 }
 export interface MixedTypeAnnotationBuilder {
-    (): N.MixedTypeAnnotation;
+    (): namedTypes.MixedTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.MixedTypeAnnotation;
+    }): namedTypes.MixedTypeAnnotation;
 }
 export interface VoidTypeAnnotationBuilder {
-    (): N.VoidTypeAnnotation;
+    (): namedTypes.VoidTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.VoidTypeAnnotation;
+    }): namedTypes.VoidTypeAnnotation;
 }
 export interface NumberTypeAnnotationBuilder {
-    (): N.NumberTypeAnnotation;
+    (): namedTypes.NumberTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.NumberTypeAnnotation;
+    }): namedTypes.NumberTypeAnnotation;
 }
 export interface NumberLiteralTypeAnnotationBuilder {
-    (value: number, raw: string): N.NumberLiteralTypeAnnotation;
+    (value: number, raw: string): namedTypes.NumberLiteralTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw: string;
         value: number;
-    }): N.NumberLiteralTypeAnnotation;
+    }): namedTypes.NumberLiteralTypeAnnotation;
 }
 export interface NumericLiteralTypeAnnotationBuilder {
-    (value: number, raw: string): N.NumericLiteralTypeAnnotation;
+    (value: number, raw: string): namedTypes.NumericLiteralTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw: string;
         value: number;
-    }): N.NumericLiteralTypeAnnotation;
+    }): namedTypes.NumericLiteralTypeAnnotation;
 }
 export interface StringTypeAnnotationBuilder {
-    (): N.StringTypeAnnotation;
+    (): namedTypes.StringTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.StringTypeAnnotation;
+    }): namedTypes.StringTypeAnnotation;
 }
 export interface StringLiteralTypeAnnotationBuilder {
-    (value: string, raw: string): N.StringLiteralTypeAnnotation;
+    (value: string, raw: string): namedTypes.StringLiteralTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw: string;
         value: string;
-    }): N.StringLiteralTypeAnnotation;
+    }): namedTypes.StringLiteralTypeAnnotation;
 }
 export interface BooleanTypeAnnotationBuilder {
-    (): N.BooleanTypeAnnotation;
+    (): namedTypes.BooleanTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.BooleanTypeAnnotation;
+    }): namedTypes.BooleanTypeAnnotation;
 }
 export interface BooleanLiteralTypeAnnotationBuilder {
-    (value: boolean, raw: string): N.BooleanLiteralTypeAnnotation;
+    (value: boolean, raw: string): namedTypes.BooleanLiteralTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         raw: string;
         value: boolean;
-    }): N.BooleanLiteralTypeAnnotation;
+    }): namedTypes.BooleanLiteralTypeAnnotation;
 }
 export interface NullableTypeAnnotationBuilder {
-    (typeAnnotation: K.FlowTypeKind): N.NullableTypeAnnotation;
+    (typeAnnotation: K.FlowTypeKind): namedTypes.NullableTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.FlowTypeKind;
-    }): N.NullableTypeAnnotation;
+    }): namedTypes.NullableTypeAnnotation;
 }
 export interface NullLiteralTypeAnnotationBuilder {
-    (): N.NullLiteralTypeAnnotation;
+    (): namedTypes.NullLiteralTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.NullLiteralTypeAnnotation;
+    }): namedTypes.NullLiteralTypeAnnotation;
 }
 export interface NullTypeAnnotationBuilder {
-    (): N.NullTypeAnnotation;
+    (): namedTypes.NullTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.NullTypeAnnotation;
+    }): namedTypes.NullTypeAnnotation;
 }
 export interface ThisTypeAnnotationBuilder {
-    (): N.ThisTypeAnnotation;
+    (): namedTypes.ThisTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ThisTypeAnnotation;
+    }): namedTypes.ThisTypeAnnotation;
 }
 export interface ExistsTypeAnnotationBuilder {
-    (): N.ExistsTypeAnnotation;
+    (): namedTypes.ExistsTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ExistsTypeAnnotation;
+    }): namedTypes.ExistsTypeAnnotation;
 }
 export interface ExistentialTypeParamBuilder {
-    (): N.ExistentialTypeParam;
+    (): namedTypes.ExistentialTypeParam;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ExistentialTypeParam;
+    }): namedTypes.ExistentialTypeParam;
 }
 export interface FunctionTypeAnnotationBuilder {
-    (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): N.FunctionTypeAnnotation;
+    (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.FunctionTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -1044,28 +1045,28 @@ export interface FunctionTypeAnnotationBuilder {
         rest: K.FunctionTypeParamKind | null;
         returnType: K.FlowTypeKind;
         typeParameters: K.TypeParameterDeclarationKind | null;
-    }): N.FunctionTypeAnnotation;
+    }): namedTypes.FunctionTypeAnnotation;
 }
 export interface FunctionTypeParamBuilder {
-    (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): N.FunctionTypeParam;
+    (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): namedTypes.FunctionTypeParam;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: K.IdentifierKind;
         optional: boolean;
         typeAnnotation: K.FlowTypeKind;
-    }): N.FunctionTypeParam;
+    }): namedTypes.FunctionTypeParam;
 }
 export interface ArrayTypeAnnotationBuilder {
-    (elementType: K.FlowTypeKind): N.ArrayTypeAnnotation;
+    (elementType: K.FlowTypeKind): namedTypes.ArrayTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         elementType: K.FlowTypeKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ArrayTypeAnnotation;
+    }): namedTypes.ArrayTypeAnnotation;
 }
 export interface ObjectTypeAnnotationBuilder {
-    (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): N.ObjectTypeAnnotation;
+    (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): namedTypes.ObjectTypeAnnotation;
     from(params: {
         callProperties?: K.ObjectTypeCallPropertyKind[];
         comments?: K.CommentKind[] | null;
@@ -1075,10 +1076,10 @@ export interface ObjectTypeAnnotationBuilder {
         internalSlots?: K.ObjectTypeInternalSlotKind[];
         loc?: K.SourceLocationKind | null;
         properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[];
-    }): N.ObjectTypeAnnotation;
+    }): namedTypes.ObjectTypeAnnotation;
 }
 export interface ObjectTypePropertyBuilder {
-    (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): N.ObjectTypeProperty;
+    (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): namedTypes.ObjectTypeProperty;
     from(params: {
         comments?: K.CommentKind[] | null;
         key: K.LiteralKind | K.IdentifierKind;
@@ -1086,18 +1087,18 @@ export interface ObjectTypePropertyBuilder {
         optional: boolean;
         value: K.FlowTypeKind;
         variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): N.ObjectTypeProperty;
+    }): namedTypes.ObjectTypeProperty;
 }
 export interface ObjectTypeSpreadPropertyBuilder {
-    (argument: K.FlowTypeKind): N.ObjectTypeSpreadProperty;
+    (argument: K.FlowTypeKind): namedTypes.ObjectTypeSpreadProperty;
     from(params: {
         argument: K.FlowTypeKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ObjectTypeSpreadProperty;
+    }): namedTypes.ObjectTypeSpreadProperty;
 }
 export interface ObjectTypeIndexerBuilder {
-    (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): N.ObjectTypeIndexer;
+    (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): namedTypes.ObjectTypeIndexer;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
@@ -1105,19 +1106,19 @@ export interface ObjectTypeIndexerBuilder {
         loc?: K.SourceLocationKind | null;
         value: K.FlowTypeKind;
         variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): N.ObjectTypeIndexer;
+    }): namedTypes.ObjectTypeIndexer;
 }
 export interface ObjectTypeCallPropertyBuilder {
-    (value: K.FunctionTypeAnnotationKind): N.ObjectTypeCallProperty;
+    (value: K.FunctionTypeAnnotationKind): namedTypes.ObjectTypeCallProperty;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         static?: boolean;
         value: K.FunctionTypeAnnotationKind;
-    }): N.ObjectTypeCallProperty;
+    }): namedTypes.ObjectTypeCallProperty;
 }
 export interface ObjectTypeInternalSlotBuilder {
-    (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): N.ObjectTypeInternalSlot;
+    (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): namedTypes.ObjectTypeInternalSlot;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
@@ -1126,97 +1127,97 @@ export interface ObjectTypeInternalSlotBuilder {
         optional: boolean;
         static: boolean;
         value: K.FlowTypeKind;
-    }): N.ObjectTypeInternalSlot;
+    }): namedTypes.ObjectTypeInternalSlot;
 }
 export interface VarianceBuilder {
-    (kind: "plus" | "minus"): N.Variance;
+    (kind: "plus" | "minus"): namedTypes.Variance;
     from(params: {
         comments?: K.CommentKind[] | null;
         kind: "plus" | "minus";
         loc?: K.SourceLocationKind | null;
-    }): N.Variance;
+    }): namedTypes.Variance;
 }
 export interface QualifiedTypeIdentifierBuilder {
-    (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): N.QualifiedTypeIdentifier;
+    (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): namedTypes.QualifiedTypeIdentifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
-    }): N.QualifiedTypeIdentifier;
+    }): namedTypes.QualifiedTypeIdentifier;
 }
 export interface GenericTypeAnnotationBuilder {
-    (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): N.GenericTypeAnnotation;
+    (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): namedTypes.GenericTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
         loc?: K.SourceLocationKind | null;
         typeParameters: K.TypeParameterInstantiationKind | null;
-    }): N.GenericTypeAnnotation;
+    }): namedTypes.GenericTypeAnnotation;
 }
 export interface MemberTypeAnnotationBuilder {
-    (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): N.MemberTypeAnnotation;
+    (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): namedTypes.MemberTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         object: K.IdentifierKind;
         property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;
-    }): N.MemberTypeAnnotation;
+    }): namedTypes.MemberTypeAnnotation;
 }
 export interface UnionTypeAnnotationBuilder {
-    (types: K.FlowTypeKind[]): N.UnionTypeAnnotation;
+    (types: K.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         types: K.FlowTypeKind[];
-    }): N.UnionTypeAnnotation;
+    }): namedTypes.UnionTypeAnnotation;
 }
 export interface IntersectionTypeAnnotationBuilder {
-    (types: K.FlowTypeKind[]): N.IntersectionTypeAnnotation;
+    (types: K.FlowTypeKind[]): namedTypes.IntersectionTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         types: K.FlowTypeKind[];
-    }): N.IntersectionTypeAnnotation;
+    }): namedTypes.IntersectionTypeAnnotation;
 }
 export interface TypeofTypeAnnotationBuilder {
-    (argument: K.FlowTypeKind): N.TypeofTypeAnnotation;
+    (argument: K.FlowTypeKind): namedTypes.TypeofTypeAnnotation;
     from(params: {
         argument: K.FlowTypeKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TypeofTypeAnnotation;
+    }): namedTypes.TypeofTypeAnnotation;
 }
 export interface TypeParameterBuilder {
-    (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): N.TypeParameter;
+    (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): namedTypes.TypeParameter;
     from(params: {
         bound?: K.TypeAnnotationKind | null;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         name: string;
         variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): N.TypeParameter;
+    }): namedTypes.TypeParameter;
 }
 export interface InterfaceTypeAnnotationBuilder {
-    (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): N.InterfaceTypeAnnotation;
+    (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): namedTypes.InterfaceTypeAnnotation;
     from(params: {
         body: K.ObjectTypeAnnotationKind;
         comments?: K.CommentKind[] | null;
         extends?: K.InterfaceExtendsKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.InterfaceTypeAnnotation;
+    }): namedTypes.InterfaceTypeAnnotation;
 }
 export interface InterfaceExtendsBuilder {
-    (id: K.IdentifierKind): N.InterfaceExtends;
+    (id: K.IdentifierKind): namedTypes.InterfaceExtends;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TypeParameterInstantiationKind | null;
-    }): N.InterfaceExtends;
+    }): namedTypes.InterfaceExtends;
 }
 export interface InterfaceDeclarationBuilder {
-    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.InterfaceDeclaration;
+    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.InterfaceDeclaration;
     from(params: {
         body: K.ObjectTypeAnnotationKind;
         comments?: K.CommentKind[] | null;
@@ -1224,10 +1225,10 @@ export interface InterfaceDeclarationBuilder {
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | null;
-    }): N.InterfaceDeclaration;
+    }): namedTypes.InterfaceDeclaration;
 }
 export interface DeclareInterfaceBuilder {
-    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.DeclareInterface;
+    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.DeclareInterface;
     from(params: {
         body: K.ObjectTypeAnnotationKind;
         comments?: K.CommentKind[] | null;
@@ -1235,20 +1236,20 @@ export interface DeclareInterfaceBuilder {
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | null;
-    }): N.DeclareInterface;
+    }): namedTypes.DeclareInterface;
 }
 export interface TypeAliasBuilder {
-    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.TypeAlias;
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.TypeAlias;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         right: K.FlowTypeKind;
         typeParameters: K.TypeParameterDeclarationKind | null;
-    }): N.TypeAlias;
+    }): namedTypes.TypeAlias;
 }
 export interface OpaqueTypeBuilder {
-    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): N.OpaqueType;
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): namedTypes.OpaqueType;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
@@ -1256,63 +1257,63 @@ export interface OpaqueTypeBuilder {
         loc?: K.SourceLocationKind | null;
         supertype: K.FlowTypeKind;
         typeParameters: K.TypeParameterDeclarationKind | null;
-    }): N.OpaqueType;
+    }): namedTypes.OpaqueType;
 }
 export interface DeclareTypeAliasBuilder {
-    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.DeclareTypeAlias;
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.DeclareTypeAlias;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         right: K.FlowTypeKind;
         typeParameters: K.TypeParameterDeclarationKind | null;
-    }): N.DeclareTypeAlias;
+    }): namedTypes.DeclareTypeAlias;
 }
 export interface DeclareOpaqueTypeBuilder {
-    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): N.DeclareOpaqueType;
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.DeclareOpaqueType;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         right: K.FlowTypeKind;
         typeParameters: K.TypeParameterDeclarationKind | null;
-    }): N.DeclareOpaqueType;
+    }): namedTypes.DeclareOpaqueType;
 }
 export interface TypeCastExpressionBuilder {
-    (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): N.TypeCastExpression;
+    (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): namedTypes.TypeCastExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TypeAnnotationKind;
-    }): N.TypeCastExpression;
+    }): namedTypes.TypeCastExpression;
 }
 export interface TupleTypeAnnotationBuilder {
-    (types: K.FlowTypeKind[]): N.TupleTypeAnnotation;
+    (types: K.FlowTypeKind[]): namedTypes.TupleTypeAnnotation;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         types: K.FlowTypeKind[];
-    }): N.TupleTypeAnnotation;
+    }): namedTypes.TupleTypeAnnotation;
 }
 export interface DeclareVariableBuilder {
-    (id: K.IdentifierKind): N.DeclareVariable;
+    (id: K.IdentifierKind): namedTypes.DeclareVariable;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.DeclareVariable;
+    }): namedTypes.DeclareVariable;
 }
 export interface DeclareFunctionBuilder {
-    (id: K.IdentifierKind): N.DeclareFunction;
+    (id: K.IdentifierKind): namedTypes.DeclareFunction;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.DeclareFunction;
+    }): namedTypes.DeclareFunction;
 }
 export interface DeclareClassBuilder {
-    (id: K.IdentifierKind): N.DeclareClass;
+    (id: K.IdentifierKind): namedTypes.DeclareClass;
     from(params: {
         body: K.ObjectTypeAnnotationKind;
         comments?: K.CommentKind[] | null;
@@ -1320,27 +1321,27 @@ export interface DeclareClassBuilder {
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | null;
-    }): N.DeclareClass;
+    }): namedTypes.DeclareClass;
 }
 export interface DeclareModuleBuilder {
-    (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): N.DeclareModule;
+    (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): namedTypes.DeclareModule;
     from(params: {
         body: K.BlockStatementKind;
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind | K.LiteralKind;
         loc?: K.SourceLocationKind | null;
-    }): N.DeclareModule;
+    }): namedTypes.DeclareModule;
 }
 export interface DeclareModuleExportsBuilder {
-    (typeAnnotation: K.TypeAnnotationKind): N.DeclareModuleExports;
+    (typeAnnotation: K.TypeAnnotationKind): namedTypes.DeclareModuleExports;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TypeAnnotationKind;
-    }): N.DeclareModuleExports;
+    }): namedTypes.DeclareModuleExports;
 }
 export interface DeclareExportDeclarationBuilder {
-    (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): N.DeclareExportDeclaration;
+    (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.DeclareExportDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null;
@@ -1348,10 +1349,10 @@ export interface DeclareExportDeclarationBuilder {
         loc?: K.SourceLocationKind | null;
         source?: K.LiteralKind | null;
         specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
-    }): N.DeclareExportDeclaration;
+    }): namedTypes.DeclareExportDeclaration;
 }
 export interface ExportSpecifierBuilder {
-    (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): N.ExportSpecifier;
+    (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): namedTypes.ExportSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         exported: K.IdentifierKind;
@@ -1359,40 +1360,40 @@ export interface ExportSpecifierBuilder {
         loc?: K.SourceLocationKind | null;
         local?: K.IdentifierKind | null;
         name?: K.IdentifierKind | null;
-    }): N.ExportSpecifier;
+    }): namedTypes.ExportSpecifier;
 }
 export interface ExportBatchSpecifierBuilder {
-    (): N.ExportBatchSpecifier;
+    (): namedTypes.ExportBatchSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.ExportBatchSpecifier;
+    }): namedTypes.ExportBatchSpecifier;
 }
 export interface DeclareExportAllDeclarationBuilder {
-    (source?: K.LiteralKind | null): N.DeclareExportAllDeclaration;
+    (source?: K.LiteralKind | null): namedTypes.DeclareExportAllDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         source?: K.LiteralKind | null;
-    }): N.DeclareExportAllDeclaration;
+    }): namedTypes.DeclareExportAllDeclaration;
 }
 export interface InferredPredicateBuilder {
-    (): N.InferredPredicate;
+    (): namedTypes.InferredPredicate;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.InferredPredicate;
+    }): namedTypes.InferredPredicate;
 }
 export interface DeclaredPredicateBuilder {
-    (value: K.ExpressionKind): N.DeclaredPredicate;
+    (value: K.ExpressionKind): namedTypes.DeclaredPredicate;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         value: K.ExpressionKind;
-    }): N.DeclaredPredicate;
+    }): namedTypes.DeclaredPredicate;
 }
 export interface ExportDeclarationBuilder {
-    (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): N.ExportDeclaration;
+    (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.ExportDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declaration: K.DeclarationKind | K.ExpressionKind | null;
@@ -1400,169 +1401,169 @@ export interface ExportDeclarationBuilder {
         loc?: K.SourceLocationKind | null;
         source?: K.LiteralKind | null;
         specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
-    }): N.ExportDeclaration;
+    }): namedTypes.ExportDeclaration;
 }
 export interface BlockBuilder {
-    (value: string, leading?: boolean, trailing?: boolean): N.Block;
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Block;
     from(params: {
         leading?: boolean;
         loc?: K.SourceLocationKind | null;
         trailing?: boolean;
         value: string;
-    }): N.Block;
+    }): namedTypes.Block;
 }
 export interface LineBuilder {
-    (value: string, leading?: boolean, trailing?: boolean): N.Line;
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Line;
     from(params: {
         leading?: boolean;
         loc?: K.SourceLocationKind | null;
         trailing?: boolean;
         value: string;
-    }): N.Line;
+    }): namedTypes.Line;
 }
 export interface NoopBuilder {
-    (): N.Noop;
+    (): namedTypes.Noop;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.Noop;
+    }): namedTypes.Noop;
 }
 export interface DoExpressionBuilder {
-    (body: K.StatementKind[]): N.DoExpression;
+    (body: K.StatementKind[]): namedTypes.DoExpression;
     from(params: {
         body: K.StatementKind[];
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.DoExpression;
+    }): namedTypes.DoExpression;
 }
 export interface SuperBuilder {
-    (): N.Super;
+    (): namedTypes.Super;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.Super;
+    }): namedTypes.Super;
 }
 export interface BindExpressionBuilder {
-    (object: K.ExpressionKind | null, callee: K.ExpressionKind): N.BindExpression;
+    (object: K.ExpressionKind | null, callee: K.ExpressionKind): namedTypes.BindExpression;
     from(params: {
         callee: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         object: K.ExpressionKind | null;
-    }): N.BindExpression;
+    }): namedTypes.BindExpression;
 }
 export interface DecoratorBuilder {
-    (expression: K.ExpressionKind): N.Decorator;
+    (expression: K.ExpressionKind): namedTypes.Decorator;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.Decorator;
+    }): namedTypes.Decorator;
 }
 export interface MetaPropertyBuilder {
-    (meta: K.IdentifierKind, property: K.IdentifierKind): N.MetaProperty;
+    (meta: K.IdentifierKind, property: K.IdentifierKind): namedTypes.MetaProperty;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         meta: K.IdentifierKind;
         property: K.IdentifierKind;
-    }): N.MetaProperty;
+    }): namedTypes.MetaProperty;
 }
 export interface ParenthesizedExpressionBuilder {
-    (expression: K.ExpressionKind): N.ParenthesizedExpression;
+    (expression: K.ExpressionKind): namedTypes.ParenthesizedExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ParenthesizedExpression;
+    }): namedTypes.ParenthesizedExpression;
 }
 export interface ExportDefaultDeclarationBuilder {
-    (declaration: K.DeclarationKind | K.ExpressionKind): N.ExportDefaultDeclaration;
+    (declaration: K.DeclarationKind | K.ExpressionKind): namedTypes.ExportDefaultDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declaration: K.DeclarationKind | K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ExportDefaultDeclaration;
+    }): namedTypes.ExportDefaultDeclaration;
 }
 export interface ExportNamedDeclarationBuilder {
-    (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): N.ExportNamedDeclaration;
+    (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): namedTypes.ExportNamedDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declaration: K.DeclarationKind | null;
         loc?: K.SourceLocationKind | null;
         source?: K.LiteralKind | null;
         specifiers?: K.ExportSpecifierKind[];
-    }): N.ExportNamedDeclaration;
+    }): namedTypes.ExportNamedDeclaration;
 }
 export interface ExportNamespaceSpecifierBuilder {
-    (exported: K.IdentifierKind): N.ExportNamespaceSpecifier;
+    (exported: K.IdentifierKind): namedTypes.ExportNamespaceSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         exported: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ExportNamespaceSpecifier;
+    }): namedTypes.ExportNamespaceSpecifier;
 }
 export interface ExportDefaultSpecifierBuilder {
-    (exported: K.IdentifierKind): N.ExportDefaultSpecifier;
+    (exported: K.IdentifierKind): namedTypes.ExportDefaultSpecifier;
     from(params: {
         comments?: K.CommentKind[] | null;
         exported: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.ExportDefaultSpecifier;
+    }): namedTypes.ExportDefaultSpecifier;
 }
 export interface ExportAllDeclarationBuilder {
-    (exported: K.IdentifierKind | null, source: K.LiteralKind): N.ExportAllDeclaration;
+    (exported: K.IdentifierKind | null, source: K.LiteralKind): namedTypes.ExportAllDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         exported: K.IdentifierKind | null;
         loc?: K.SourceLocationKind | null;
         source: K.LiteralKind;
-    }): N.ExportAllDeclaration;
+    }): namedTypes.ExportAllDeclaration;
 }
 export interface CommentBlockBuilder {
-    (value: string, leading?: boolean, trailing?: boolean): N.CommentBlock;
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentBlock;
     from(params: {
         leading?: boolean;
         loc?: K.SourceLocationKind | null;
         trailing?: boolean;
         value: string;
-    }): N.CommentBlock;
+    }): namedTypes.CommentBlock;
 }
 export interface CommentLineBuilder {
-    (value: string, leading?: boolean, trailing?: boolean): N.CommentLine;
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentLine;
     from(params: {
         leading?: boolean;
         loc?: K.SourceLocationKind | null;
         trailing?: boolean;
         value: string;
-    }): N.CommentLine;
+    }): namedTypes.CommentLine;
 }
 export interface DirectiveBuilder {
-    (value: K.DirectiveLiteralKind): N.Directive;
+    (value: K.DirectiveLiteralKind): namedTypes.Directive;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         value: K.DirectiveLiteralKind;
-    }): N.Directive;
+    }): namedTypes.Directive;
 }
 export interface DirectiveLiteralBuilder {
-    (value?: string): N.DirectiveLiteral;
+    (value?: string): namedTypes.DirectiveLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         value?: string;
-    }): N.DirectiveLiteral;
+    }): namedTypes.DirectiveLiteral;
 }
 export interface InterpreterDirectiveBuilder {
-    (value: string): N.InterpreterDirective;
+    (value: string): namedTypes.InterpreterDirective;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         value: string;
-    }): N.InterpreterDirective;
+    }): namedTypes.InterpreterDirective;
 }
 export interface StringLiteralBuilder {
-    (value: string): N.StringLiteral;
+    (value: string): namedTypes.StringLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -1571,10 +1572,10 @@ export interface StringLiteralBuilder {
             flags: string;
         } | null;
         value: string;
-    }): N.StringLiteral;
+    }): namedTypes.StringLiteral;
 }
 export interface NumericLiteralBuilder {
-    (value: number): N.NumericLiteral;
+    (value: number): namedTypes.NumericLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         extra?: {
@@ -1588,10 +1589,10 @@ export interface NumericLiteralBuilder {
             flags: string;
         } | null;
         value: number;
-    }): N.NumericLiteral;
+    }): namedTypes.NumericLiteral;
 }
 export interface BigIntLiteralBuilder {
-    (value: string | number): N.BigIntLiteral;
+    (value: string | number): namedTypes.BigIntLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         extra?: {
@@ -1604,10 +1605,10 @@ export interface BigIntLiteralBuilder {
             flags: string;
         } | null;
         value: string | number;
-    }): N.BigIntLiteral;
+    }): namedTypes.BigIntLiteral;
 }
 export interface NullLiteralBuilder {
-    (): N.NullLiteral;
+    (): namedTypes.NullLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -1616,10 +1617,10 @@ export interface NullLiteralBuilder {
             flags: string;
         } | null;
         value?: null;
-    }): N.NullLiteral;
+    }): namedTypes.NullLiteral;
 }
 export interface BooleanLiteralBuilder {
-    (value: boolean): N.BooleanLiteral;
+    (value: boolean): namedTypes.BooleanLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -1628,10 +1629,10 @@ export interface BooleanLiteralBuilder {
             flags: string;
         } | null;
         value: boolean;
-    }): N.BooleanLiteral;
+    }): namedTypes.BooleanLiteral;
 }
 export interface RegExpLiteralBuilder {
-    (pattern: string, flags: string): N.RegExpLiteral;
+    (pattern: string, flags: string): namedTypes.RegExpLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         flags: string;
@@ -1642,10 +1643,10 @@ export interface RegExpLiteralBuilder {
             flags: string;
         } | null;
         value?: RegExp;
-    }): N.RegExpLiteral;
+    }): namedTypes.RegExpLiteral;
 }
 export interface ObjectMethodBuilder {
-    (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): N.ObjectMethod;
+    (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;
@@ -1664,11 +1665,12 @@ export interface ObjectMethodBuilder {
         rest?: K.IdentifierKind | null;
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ObjectMethod;
+    }): namedTypes.ObjectMethod;
 }
 export interface ClassPrivatePropertyBuilder {
-    (key: K.PrivateNameKind, value?: K.ExpressionKind | null): N.ClassPrivateProperty;
+    (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;
@@ -1677,10 +1679,10 @@ export interface ClassPrivatePropertyBuilder {
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         value?: K.ExpressionKind | null;
         variance?: K.VarianceKind | "plus" | "minus" | null;
-    }): N.ClassPrivateProperty;
+    }): namedTypes.ClassPrivateProperty;
 }
 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): N.ClassMethod;
+    (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: {
         abstract?: boolean | null;
         access?: "public" | "private" | "protected" | null;
@@ -1703,10 +1705,10 @@ export interface ClassMethodBuilder {
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         static?: boolean | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ClassMethod;
+    }): namedTypes.ClassMethod;
 }
 export interface ClassPrivateMethodBuilder {
-    (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean | null): N.ClassPrivateMethod;
+    (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean | null): namedTypes.ClassPrivateMethod;
     from(params: {
         abstract?: boolean | null;
         access?: "public" | "private" | "protected" | null;
@@ -1729,61 +1731,61 @@ export interface ClassPrivateMethodBuilder {
         returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
         static?: boolean | null;
         typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
-    }): N.ClassPrivateMethod;
+    }): namedTypes.ClassPrivateMethod;
 }
 export interface PrivateNameBuilder {
-    (id: K.IdentifierKind): N.PrivateName;
+    (id: K.IdentifierKind): namedTypes.PrivateName;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.PrivateName;
+    }): namedTypes.PrivateName;
 }
 export interface RestPropertyBuilder {
-    (argument: K.ExpressionKind): N.RestProperty;
+    (argument: K.ExpressionKind): namedTypes.RestProperty;
     from(params: {
         argument: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.RestProperty;
+    }): namedTypes.RestProperty;
 }
 export interface ForAwaitStatementBuilder {
-    (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): N.ForAwaitStatement;
+    (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForAwaitStatement;
     from(params: {
         body: K.StatementKind;
         comments?: K.CommentKind[] | null;
         left: K.VariableDeclarationKind | K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         right: K.ExpressionKind;
-    }): N.ForAwaitStatement;
+    }): namedTypes.ForAwaitStatement;
 }
 export interface ImportBuilder {
-    (): N.Import;
+    (): namedTypes.Import;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.Import;
+    }): namedTypes.Import;
 }
 export interface TSQualifiedNameBuilder {
-    (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): N.TSQualifiedName;
+    (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): namedTypes.TSQualifiedName;
     from(params: {
         comments?: K.CommentKind[] | null;
         left: K.IdentifierKind | K.TSQualifiedNameKind;
         loc?: K.SourceLocationKind | null;
         right: K.IdentifierKind | K.TSQualifiedNameKind;
-    }): N.TSQualifiedName;
+    }): namedTypes.TSQualifiedName;
 }
 export interface TSTypeReferenceBuilder {
-    (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSTypeReference;
+    (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSTypeReference;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeName: K.IdentifierKind | K.TSQualifiedNameKind;
         typeParameters?: K.TSTypeParameterInstantiationKind | null;
-    }): N.TSTypeReference;
+    }): namedTypes.TSTypeReference;
 }
 export interface TSAsExpressionBuilder {
-    (expression: K.ExpressionKind): N.TSAsExpression;
+    (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSAsExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
@@ -1792,141 +1794,141 @@ export interface TSAsExpressionBuilder {
         } | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSAsExpression;
+    }): namedTypes.TSAsExpression;
 }
 export interface TSNonNullExpressionBuilder {
-    (expression: K.ExpressionKind): N.TSNonNullExpression;
+    (expression: K.ExpressionKind): namedTypes.TSNonNullExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSNonNullExpression;
+    }): namedTypes.TSNonNullExpression;
 }
 export interface TSAnyKeywordBuilder {
-    (): N.TSAnyKeyword;
+    (): namedTypes.TSAnyKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSAnyKeyword;
+    }): namedTypes.TSAnyKeyword;
 }
 export interface TSBigIntKeywordBuilder {
-    (): N.TSBigIntKeyword;
+    (): namedTypes.TSBigIntKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSBigIntKeyword;
+    }): namedTypes.TSBigIntKeyword;
 }
 export interface TSBooleanKeywordBuilder {
-    (): N.TSBooleanKeyword;
+    (): namedTypes.TSBooleanKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSBooleanKeyword;
+    }): namedTypes.TSBooleanKeyword;
 }
 export interface TSNeverKeywordBuilder {
-    (): N.TSNeverKeyword;
+    (): namedTypes.TSNeverKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSNeverKeyword;
+    }): namedTypes.TSNeverKeyword;
 }
 export interface TSNullKeywordBuilder {
-    (): N.TSNullKeyword;
+    (): namedTypes.TSNullKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSNullKeyword;
+    }): namedTypes.TSNullKeyword;
 }
 export interface TSNumberKeywordBuilder {
-    (): N.TSNumberKeyword;
+    (): namedTypes.TSNumberKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSNumberKeyword;
+    }): namedTypes.TSNumberKeyword;
 }
 export interface TSObjectKeywordBuilder {
-    (): N.TSObjectKeyword;
+    (): namedTypes.TSObjectKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSObjectKeyword;
+    }): namedTypes.TSObjectKeyword;
 }
 export interface TSStringKeywordBuilder {
-    (): N.TSStringKeyword;
+    (): namedTypes.TSStringKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSStringKeyword;
+    }): namedTypes.TSStringKeyword;
 }
 export interface TSSymbolKeywordBuilder {
-    (): N.TSSymbolKeyword;
+    (): namedTypes.TSSymbolKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSSymbolKeyword;
+    }): namedTypes.TSSymbolKeyword;
 }
 export interface TSUndefinedKeywordBuilder {
-    (): N.TSUndefinedKeyword;
+    (): namedTypes.TSUndefinedKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSUndefinedKeyword;
+    }): namedTypes.TSUndefinedKeyword;
 }
 export interface TSUnknownKeywordBuilder {
-    (): N.TSUnknownKeyword;
+    (): namedTypes.TSUnknownKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSUnknownKeyword;
+    }): namedTypes.TSUnknownKeyword;
 }
 export interface TSVoidKeywordBuilder {
-    (): N.TSVoidKeyword;
+    (): namedTypes.TSVoidKeyword;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSVoidKeyword;
+    }): namedTypes.TSVoidKeyword;
 }
 export interface TSThisTypeBuilder {
-    (): N.TSThisType;
+    (): namedTypes.TSThisType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSThisType;
+    }): namedTypes.TSThisType;
 }
 export interface TSArrayTypeBuilder {
-    (elementType: K.TSTypeKind): N.TSArrayType;
+    (elementType: K.TSTypeKind): namedTypes.TSArrayType;
     from(params: {
         comments?: K.CommentKind[] | null;
         elementType: K.TSTypeKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSArrayType;
+    }): namedTypes.TSArrayType;
 }
 export interface TSLiteralTypeBuilder {
-    (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind): N.TSLiteralType;
+    (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind): namedTypes.TSLiteralType;
     from(params: {
         comments?: K.CommentKind[] | null;
-        literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind;
+        literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSLiteralType;
+    }): namedTypes.TSLiteralType;
 }
 export interface TSUnionTypeBuilder {
-    (types: K.TSTypeKind[]): N.TSUnionType;
+    (types: K.TSTypeKind[]): namedTypes.TSUnionType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         types: K.TSTypeKind[];
-    }): N.TSUnionType;
+    }): namedTypes.TSUnionType;
 }
 export interface TSIntersectionTypeBuilder {
-    (types: K.TSTypeKind[]): N.TSIntersectionType;
+    (types: K.TSTypeKind[]): namedTypes.TSIntersectionType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         types: K.TSTypeKind[];
-    }): N.TSIntersectionType;
+    }): namedTypes.TSIntersectionType;
 }
 export interface TSConditionalTypeBuilder {
-    (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): N.TSConditionalType;
+    (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): namedTypes.TSConditionalType;
     from(params: {
         checkType: K.TSTypeKind;
         comments?: K.CommentKind[] | null;
@@ -1934,18 +1936,18 @@ export interface TSConditionalTypeBuilder {
         falseType: K.TSTypeKind;
         loc?: K.SourceLocationKind | null;
         trueType: K.TSTypeKind;
-    }): N.TSConditionalType;
+    }): namedTypes.TSConditionalType;
 }
 export interface TSInferTypeBuilder {
-    (typeParameter: K.TSTypeParameterKind): N.TSInferType;
+    (typeParameter: K.TSTypeParameterKind): namedTypes.TSInferType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeParameter: K.TSTypeParameterKind;
-    }): N.TSInferType;
+    }): namedTypes.TSInferType;
 }
 export interface TSTypeParameterBuilder {
-    (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): N.TSTypeParameter;
+    (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): namedTypes.TSTypeParameter;
     from(params: {
         comments?: K.CommentKind[] | null;
         constraint?: K.TSTypeKind | undefined;
@@ -1954,38 +1956,38 @@ export interface TSTypeParameterBuilder {
         name: string;
         optional?: boolean;
         typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
-    }): N.TSTypeParameter;
+    }): namedTypes.TSTypeParameter;
 }
 export interface TSParenthesizedTypeBuilder {
-    (typeAnnotation: K.TSTypeKind): N.TSParenthesizedType;
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSParenthesizedType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSParenthesizedType;
+    }): namedTypes.TSParenthesizedType;
 }
 export interface TSFunctionTypeBuilder {
-    (parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[]): N.TSFunctionType;
+    (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSFunctionType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[];
+        parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
         typeAnnotation?: K.TSTypeAnnotationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSFunctionType;
+    }): namedTypes.TSFunctionType;
 }
 export interface TSConstructorTypeBuilder {
-    (parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[]): N.TSConstructorType;
+    (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSConstructorType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[];
+        parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
         typeAnnotation?: K.TSTypeAnnotationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSConstructorType;
+    }): namedTypes.TSConstructorType;
 }
 export interface TSDeclareFunctionBuilder {
-    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareFunction;
+    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareFunction;
     from(params: {
         async?: boolean;
         comments?: K.CommentKind[] | null;
@@ -1996,10 +1998,10 @@ export interface TSDeclareFunctionBuilder {
         params: K.PatternKind[];
         returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSDeclareFunction;
+    }): namedTypes.TSDeclareFunction;
 }
 export interface TSDeclareMethodBuilder {
-    (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareMethod;
+    (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareMethod;
     from(params: {
         abstract?: boolean;
         access?: "public" | "private" | "protected" | undefined;
@@ -2017,10 +2019,10 @@ export interface TSDeclareMethodBuilder {
         returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
         static?: boolean;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSDeclareMethod;
+    }): namedTypes.TSDeclareMethod;
 }
 export interface TSMappedTypeBuilder {
-    (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): N.TSMappedType;
+    (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): namedTypes.TSMappedType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
@@ -2028,62 +2030,62 @@ export interface TSMappedTypeBuilder {
         readonly?: boolean | "+" | "-";
         typeAnnotation?: K.TSTypeKind | null;
         typeParameter: K.TSTypeParameterKind;
-    }): N.TSMappedType;
+    }): namedTypes.TSMappedType;
 }
 export interface TSTupleTypeBuilder {
-    (elementTypes: K.TSTypeKind[]): N.TSTupleType;
+    (elementTypes: K.TSTypeKind[]): namedTypes.TSTupleType;
     from(params: {
         comments?: K.CommentKind[] | null;
         elementTypes: K.TSTypeKind[];
         loc?: K.SourceLocationKind | null;
-    }): N.TSTupleType;
+    }): namedTypes.TSTupleType;
 }
 export interface TSRestTypeBuilder {
-    (typeAnnotation: K.TSTypeKind): N.TSRestType;
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSRestType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSRestType;
+    }): namedTypes.TSRestType;
 }
 export interface TSOptionalTypeBuilder {
-    (typeAnnotation: K.TSTypeKind): N.TSOptionalType;
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSOptionalType;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSOptionalType;
+    }): namedTypes.TSOptionalType;
 }
 export interface TSIndexedAccessTypeBuilder {
-    (objectType: K.TSTypeKind, indexType: K.TSTypeKind): N.TSIndexedAccessType;
+    (objectType: K.TSTypeKind, indexType: K.TSTypeKind): namedTypes.TSIndexedAccessType;
     from(params: {
         comments?: K.CommentKind[] | null;
         indexType: K.TSTypeKind;
         loc?: K.SourceLocationKind | null;
         objectType: K.TSTypeKind;
-    }): N.TSIndexedAccessType;
+    }): namedTypes.TSIndexedAccessType;
 }
 export interface TSTypeOperatorBuilder {
-    (operator: string): N.TSTypeOperator;
+    (operator: string): namedTypes.TSTypeOperator;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         operator: string;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSTypeOperator;
+    }): namedTypes.TSTypeOperator;
 }
 export interface TSIndexSignatureBuilder {
-    (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSIndexSignature;
+    (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSIndexSignature;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         parameters: K.IdentifierKind[];
         readonly?: boolean;
         typeAnnotation?: K.TSTypeAnnotationKind | null;
-    }): N.TSIndexSignature;
+    }): namedTypes.TSIndexSignature;
 }
 export interface TSPropertySignatureBuilder {
-    (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): N.TSPropertySignature;
+    (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): namedTypes.TSPropertySignature;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
@@ -2093,87 +2095,87 @@ export interface TSPropertySignatureBuilder {
         optional?: boolean;
         readonly?: boolean;
         typeAnnotation?: K.TSTypeAnnotationKind | null;
-    }): N.TSPropertySignature;
+    }): namedTypes.TSPropertySignature;
 }
 export interface TSMethodSignatureBuilder {
-    (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSMethodSignature;
+    (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSMethodSignature;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
         key: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
         optional?: boolean;
-        parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[];
+        parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
         typeAnnotation?: K.TSTypeAnnotationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSMethodSignature;
+    }): namedTypes.TSMethodSignature;
 }
 export interface TSTypePredicateBuilder {
-    (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): N.TSTypePredicate;
+    (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): namedTypes.TSTypePredicate;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         parameterName: K.IdentifierKind | K.TSThisTypeKind;
         typeAnnotation: K.TSTypeAnnotationKind;
-    }): N.TSTypePredicate;
+    }): namedTypes.TSTypePredicate;
 }
 export interface TSCallSignatureDeclarationBuilder {
-    (parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSCallSignatureDeclaration;
+    (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSCallSignatureDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[];
+        parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
         typeAnnotation?: K.TSTypeAnnotationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSCallSignatureDeclaration;
+    }): namedTypes.TSCallSignatureDeclaration;
 }
 export interface TSConstructSignatureDeclarationBuilder {
-    (parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSConstructSignatureDeclaration;
+    (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSConstructSignatureDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-        parameters: (K.IdentifierKind | K.RestElementKind | K.ObjectPatternKind)[];
+        parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
         typeAnnotation?: K.TSTypeAnnotationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSConstructSignatureDeclaration;
+    }): namedTypes.TSConstructSignatureDeclaration;
 }
 export interface TSEnumMemberBuilder {
-    (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): N.TSEnumMember;
+    (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): namedTypes.TSEnumMember;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind | K.StringLiteralKind;
         initializer?: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSEnumMember;
+    }): namedTypes.TSEnumMember;
 }
 export interface TSTypeQueryBuilder {
-    (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): N.TSTypeQuery;
+    (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): namedTypes.TSTypeQuery;
     from(params: {
         comments?: K.CommentKind[] | null;
         exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSTypeQuery;
+    }): namedTypes.TSTypeQuery;
 }
 export interface TSImportTypeBuilder {
-    (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSImportType;
+    (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSImportType;
     from(params: {
         argument: K.StringLiteralKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined;
         typeParameters?: K.TSTypeParameterInstantiationKind | null;
-    }): N.TSImportType;
+    }): namedTypes.TSImportType;
 }
 export interface TSTypeLiteralBuilder {
-    (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSTypeLiteral;
+    (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSTypeLiteral;
     from(params: {
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
-    }): N.TSTypeLiteral;
+    }): namedTypes.TSTypeLiteral;
 }
 export interface TSTypeAssertionBuilder {
-    (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): N.TSTypeAssertion;
+    (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): namedTypes.TSTypeAssertion;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
@@ -2182,10 +2184,10 @@ export interface TSTypeAssertionBuilder {
         } | null;
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
-    }): N.TSTypeAssertion;
+    }): namedTypes.TSTypeAssertion;
 }
 export interface TSEnumDeclarationBuilder {
-    (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): N.TSEnumDeclaration;
+    (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): namedTypes.TSEnumDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         const?: boolean;
@@ -2194,10 +2196,10 @@ export interface TSEnumDeclarationBuilder {
         initializer?: K.ExpressionKind | null;
         loc?: K.SourceLocationKind | null;
         members: K.TSEnumMemberKind[];
-    }): N.TSEnumDeclaration;
+    }): namedTypes.TSEnumDeclaration;
 }
 export interface TSTypeAliasDeclarationBuilder {
-    (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): N.TSTypeAliasDeclaration;
+    (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): namedTypes.TSTypeAliasDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         declare?: boolean;
@@ -2205,18 +2207,18 @@ export interface TSTypeAliasDeclarationBuilder {
         loc?: K.SourceLocationKind | null;
         typeAnnotation: K.TSTypeKind;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSTypeAliasDeclaration;
+    }): namedTypes.TSTypeAliasDeclaration;
 }
 export interface TSModuleBlockBuilder {
-    (body: K.StatementKind[]): N.TSModuleBlock;
+    (body: K.StatementKind[]): namedTypes.TSModuleBlock;
     from(params: {
         body: K.StatementKind[];
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSModuleBlock;
+    }): namedTypes.TSModuleBlock;
 }
 export interface TSModuleDeclarationBuilder {
-    (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): N.TSModuleDeclaration;
+    (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): namedTypes.TSModuleDeclaration;
     from(params: {
         body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null;
         comments?: K.CommentKind[] | null;
@@ -2224,52 +2226,52 @@ export interface TSModuleDeclarationBuilder {
         global?: boolean;
         id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSModuleDeclaration;
+    }): namedTypes.TSModuleDeclaration;
 }
 export interface TSImportEqualsDeclarationBuilder {
-    (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): N.TSImportEqualsDeclaration;
+    (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): namedTypes.TSImportEqualsDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         isExport?: boolean;
         loc?: K.SourceLocationKind | null;
         moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind;
-    }): N.TSImportEqualsDeclaration;
+    }): namedTypes.TSImportEqualsDeclaration;
 }
 export interface TSExternalModuleReferenceBuilder {
-    (expression: K.StringLiteralKind): N.TSExternalModuleReference;
+    (expression: K.StringLiteralKind): namedTypes.TSExternalModuleReference;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.StringLiteralKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSExternalModuleReference;
+    }): namedTypes.TSExternalModuleReference;
 }
 export interface TSExportAssignmentBuilder {
-    (expression: K.ExpressionKind): N.TSExportAssignment;
+    (expression: K.ExpressionKind): namedTypes.TSExportAssignment;
     from(params: {
         comments?: K.CommentKind[] | null;
         expression: K.ExpressionKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSExportAssignment;
+    }): namedTypes.TSExportAssignment;
 }
 export interface TSNamespaceExportDeclarationBuilder {
-    (id: K.IdentifierKind): N.TSNamespaceExportDeclaration;
+    (id: K.IdentifierKind): namedTypes.TSNamespaceExportDeclaration;
     from(params: {
         comments?: K.CommentKind[] | null;
         id: K.IdentifierKind;
         loc?: K.SourceLocationKind | null;
-    }): N.TSNamespaceExportDeclaration;
+    }): namedTypes.TSNamespaceExportDeclaration;
 }
 export interface TSInterfaceBodyBuilder {
-    (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSInterfaceBody;
+    (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSInterfaceBody;
     from(params: {
         body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
-    }): N.TSInterfaceBody;
+    }): namedTypes.TSInterfaceBody;
 }
 export interface TSInterfaceDeclarationBuilder {
-    (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): N.TSInterfaceDeclaration;
+    (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): namedTypes.TSInterfaceDeclaration;
     from(params: {
         body: K.TSInterfaceBodyKind;
         comments?: K.CommentKind[] | null;
@@ -2278,20 +2280,20 @@ export interface TSInterfaceDeclarationBuilder {
         id: K.IdentifierKind | K.TSQualifiedNameKind;
         loc?: K.SourceLocationKind | null;
         typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
-    }): N.TSInterfaceDeclaration;
+    }): namedTypes.TSInterfaceDeclaration;
 }
 export interface TSParameterPropertyBuilder {
-    (parameter: K.IdentifierKind | K.AssignmentPatternKind): N.TSParameterProperty;
+    (parameter: K.IdentifierKind | K.AssignmentPatternKind): namedTypes.TSParameterProperty;
     from(params: {
         accessibility?: "public" | "private" | "protected" | undefined;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         parameter: K.IdentifierKind | K.AssignmentPatternKind;
         readonly?: boolean;
-    }): N.TSParameterProperty;
+    }): namedTypes.TSParameterProperty;
 }
 export interface OptionalMemberExpressionBuilder {
-    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): N.OptionalMemberExpression;
+    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
     from(params: {
         comments?: K.CommentKind[] | null;
         computed?: boolean;
@@ -2299,19 +2301,19 @@ export interface OptionalMemberExpressionBuilder {
         object: K.ExpressionKind;
         optional?: boolean;
         property: K.IdentifierKind | K.ExpressionKind;
-    }): N.OptionalMemberExpression;
+    }): namedTypes.OptionalMemberExpression;
 }
 export interface OptionalCallExpressionBuilder {
-    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): N.OptionalCallExpression;
+    (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): namedTypes.OptionalCallExpression;
     from(params: {
         arguments: (K.ExpressionKind | K.SpreadElementKind)[];
         callee: K.ExpressionKind;
         comments?: K.CommentKind[] | null;
         loc?: K.SourceLocationKind | null;
         optional?: boolean;
-    }): N.OptionalCallExpression;
+    }): namedTypes.OptionalCallExpression;
 }
-export interface Builders {
+export interface builders {
     file: FileBuilder;
     program: ProgramBuilder;
     identifier: IdentifierBuilder;
@@ -2347,12 +2349,12 @@ export interface Builders {
     unaryExpression: UnaryExpressionBuilder;
     binaryExpression: BinaryExpressionBuilder;
     assignmentExpression: AssignmentExpressionBuilder;
+    memberExpression: MemberExpressionBuilder;
     updateExpression: UpdateExpressionBuilder;
     logicalExpression: LogicalExpressionBuilder;
     conditionalExpression: ConditionalExpressionBuilder;
     newExpression: NewExpressionBuilder;
     callExpression: CallExpressionBuilder;
-    memberExpression: MemberExpressionBuilder;
     restElement: RestElementBuilder;
     typeAnnotation: TypeAnnotationBuilder;
     tsTypeAnnotation: TSTypeAnnotationBuilder;