immosquare-cleaner 0.1.36 → 0.1.37

data/node_modules/ast-types/lib/gen/builders.d.ts

@@ -0,0 +1,2850 @@
+import * as K from "./kinds";
+import { namedTypes } from "./namedTypes";
+export interface FileBuilder {
+    (program: K.ProgramKind, name?: string | null): namedTypes.File;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name?: string | null;
+        program: K.ProgramKind;
+    }): namedTypes.File;
+}
+export interface ProgramBuilder {
+    (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;
+    }): namedTypes.Program;
+}
+export interface IdentifierBuilder {
+    (name: string): namedTypes.Identifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: string;
+        optional?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+    }): namedTypes.Identifier;
+}
+export interface BlockStatementBuilder {
+    (body: K.StatementKind[]): namedTypes.BlockStatement;
+    from(params: {
+        body: K.StatementKind[];
+        comments?: K.CommentKind[] | null;
+        directives?: K.DirectiveKind[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.BlockStatement;
+}
+export interface EmptyStatementBuilder {
+    (): namedTypes.EmptyStatement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.EmptyStatement;
+}
+export interface ExpressionStatementBuilder {
+    (expression: K.ExpressionKind): namedTypes.ExpressionStatement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExpressionStatement;
+}
+export interface IfStatementBuilder {
+    (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;
+    }): namedTypes.IfStatement;
+}
+export interface LabeledStatementBuilder {
+    (label: K.IdentifierKind, body: K.StatementKind): namedTypes.LabeledStatement;
+    from(params: {
+        body: K.StatementKind;
+        comments?: K.CommentKind[] | null;
+        label: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.LabeledStatement;
+}
+export interface BreakStatementBuilder {
+    (label?: K.IdentifierKind | null): namedTypes.BreakStatement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        label?: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.BreakStatement;
+}
+export interface ContinueStatementBuilder {
+    (label?: K.IdentifierKind | null): namedTypes.ContinueStatement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        label?: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ContinueStatement;
+}
+export interface WithStatementBuilder {
+    (object: K.ExpressionKind, body: K.StatementKind): namedTypes.WithStatement;
+    from(params: {
+        body: K.StatementKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        object: K.ExpressionKind;
+    }): namedTypes.WithStatement;
+}
+export interface SwitchStatementBuilder {
+    (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;
+    }): namedTypes.SwitchStatement;
+}
+export interface SwitchCaseBuilder {
+    (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;
+    }): namedTypes.SwitchCase;
+}
+export interface ReturnStatementBuilder {
+    (argument: K.ExpressionKind | null): namedTypes.ReturnStatement;
+    from(params: {
+        argument: K.ExpressionKind | null;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ReturnStatement;
+}
+export interface ThrowStatementBuilder {
+    (argument: K.ExpressionKind): namedTypes.ThrowStatement;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ThrowStatement;
+}
+export interface TryStatementBuilder {
+    (block: K.BlockStatementKind, handler?: K.CatchClauseKind | null, finalizer?: K.BlockStatementKind | null): namedTypes.TryStatement;
+    from(params: {
+        block: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        finalizer?: K.BlockStatementKind | null;
+        guardedHandlers?: K.CatchClauseKind[];
+        handler?: K.CatchClauseKind | null;
+        handlers?: K.CatchClauseKind[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TryStatement;
+}
+export interface CatchClauseBuilder {
+    (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;
+    }): namedTypes.CatchClause;
+}
+export interface WhileStatementBuilder {
+    (test: K.ExpressionKind, body: K.StatementKind): namedTypes.WhileStatement;
+    from(params: {
+        body: K.StatementKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        test: K.ExpressionKind;
+    }): namedTypes.WhileStatement;
+}
+export interface DoWhileStatementBuilder {
+    (body: K.StatementKind, test: K.ExpressionKind): namedTypes.DoWhileStatement;
+    from(params: {
+        body: K.StatementKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        test: K.ExpressionKind;
+    }): namedTypes.DoWhileStatement;
+}
+export interface ForStatementBuilder {
+    (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;
+        init: K.VariableDeclarationKind | K.ExpressionKind | null;
+        loc?: K.SourceLocationKind | null;
+        test: K.ExpressionKind | null;
+        update: K.ExpressionKind | null;
+    }): namedTypes.ForStatement;
+}
+export interface VariableDeclarationBuilder {
+    (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;
+    }): namedTypes.VariableDeclaration;
+}
+export interface ForInStatementBuilder {
+    (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;
+    }): namedTypes.ForInStatement;
+}
+export interface DebuggerStatementBuilder {
+    (): namedTypes.DebuggerStatement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.DebuggerStatement;
+}
+export interface FunctionDeclarationBuilder {
+    (id: K.IdentifierKind | null, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionDeclaration;
+    from(params: {
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        expression?: boolean;
+        generator?: boolean;
+        id: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.FunctionDeclaration;
+}
+export interface FunctionExpressionBuilder {
+    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionExpression;
+    from(params: {
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        expression?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.FunctionExpression;
+}
+export interface VariableDeclaratorBuilder {
+    (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;
+    }): namedTypes.VariableDeclarator;
+}
+export interface ThisExpressionBuilder {
+    (): namedTypes.ThisExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ThisExpression;
+}
+export interface ArrayExpressionBuilder {
+    (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;
+    }): namedTypes.ArrayExpression;
+}
+export interface ObjectExpressionBuilder {
+    (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)[];
+    }): namedTypes.ObjectExpression;
+}
+export interface PropertyBuilder {
+    (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;
+        decorators?: K.DecoratorKind[] | null;
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        kind: "init" | "get" | "set";
+        loc?: K.SourceLocationKind | null;
+        method?: boolean;
+        shorthand?: boolean;
+        value: K.ExpressionKind | K.PatternKind;
+    }): namedTypes.Property;
+}
+export interface LiteralBuilder {
+    (value: string | boolean | null | number | RegExp | BigInt): namedTypes.Literal;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value: string | boolean | null | number | RegExp | BigInt;
+    }): namedTypes.Literal;
+}
+export interface SequenceExpressionBuilder {
+    (expressions: K.ExpressionKind[]): namedTypes.SequenceExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expressions: K.ExpressionKind[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SequenceExpression;
+}
+export interface UnaryExpressionBuilder {
+    (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;
+    }): namedTypes.UnaryExpression;
+}
+export interface BinaryExpressionBuilder {
+    (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;
+    }): namedTypes.BinaryExpression;
+}
+export interface AssignmentExpressionBuilder {
+    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=", left: K.PatternKind | K.MemberExpressionKind, right: K.ExpressionKind): namedTypes.AssignmentExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        left: K.PatternKind | K.MemberExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=";
+        right: K.ExpressionKind;
+    }): 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;
+        optional?: boolean;
+        property: K.IdentifierKind | K.ExpressionKind;
+    }): namedTypes.MemberExpression;
+}
+export interface UpdateExpressionBuilder {
+    (operator: "++" | "--", argument: K.ExpressionKind, prefix: boolean): namedTypes.UpdateExpression;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        operator: "++" | "--";
+        prefix: boolean;
+    }): namedTypes.UpdateExpression;
+}
+export interface LogicalExpressionBuilder {
+    (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;
+    }): namedTypes.LogicalExpression;
+}
+export interface ConditionalExpressionBuilder {
+    (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;
+    }): namedTypes.ConditionalExpression;
+}
+export interface NewExpressionBuilder {
+    (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;
+        typeArguments?: null | K.TypeParameterInstantiationKind;
+    }): namedTypes.NewExpression;
+}
+export interface CallExpressionBuilder {
+    (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;
+        optional?: boolean;
+        typeArguments?: null | K.TypeParameterInstantiationKind;
+    }): namedTypes.CallExpression;
+}
+export interface RestElementBuilder {
+    (argument: K.PatternKind): namedTypes.RestElement;
+    from(params: {
+        argument: K.PatternKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+    }): namedTypes.RestElement;
+}
+export interface TypeAnnotationBuilder {
+    (typeAnnotation: K.FlowTypeKind): namedTypes.TypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.FlowTypeKind;
+    }): namedTypes.TypeAnnotation;
+}
+export interface TSTypeAnnotationBuilder {
+    (typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind): namedTypes.TSTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind;
+    }): namedTypes.TSTypeAnnotation;
+}
+export interface SpreadElementPatternBuilder {
+    (argument: K.PatternKind): namedTypes.SpreadElementPattern;
+    from(params: {
+        argument: K.PatternKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SpreadElementPattern;
+}
+export interface ArrowFunctionExpressionBuilder {
+    (params: K.PatternKind[], body: K.BlockStatementKind | K.ExpressionKind, expression?: boolean): namedTypes.ArrowFunctionExpression;
+    from(params: {
+        async?: boolean;
+        body: K.BlockStatementKind | K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        expression?: boolean;
+        generator?: false;
+        id?: null;
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ArrowFunctionExpression;
+}
+export interface ForOfStatementBuilder {
+    (left: K.VariableDeclarationKind | K.PatternKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForOfStatement;
+    from(params: {
+        await?: boolean;
+        body: K.StatementKind;
+        comments?: K.CommentKind[] | null;
+        left: K.VariableDeclarationKind | K.PatternKind;
+        loc?: K.SourceLocationKind | null;
+        right: K.ExpressionKind;
+    }): namedTypes.ForOfStatement;
+}
+export interface YieldExpressionBuilder {
+    (argument: K.ExpressionKind | null, delegate?: boolean): namedTypes.YieldExpression;
+    from(params: {
+        argument: K.ExpressionKind | null;
+        comments?: K.CommentKind[] | null;
+        delegate?: boolean;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.YieldExpression;
+}
+export interface GeneratorExpressionBuilder {
+    (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;
+    }): namedTypes.GeneratorExpression;
+}
+export interface ComprehensionBlockBuilder {
+    (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;
+    }): namedTypes.ComprehensionBlock;
+}
+export interface ComprehensionExpressionBuilder {
+    (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;
+    }): namedTypes.ComprehensionExpression;
+}
+export interface ObjectPropertyBuilder {
+    (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): namedTypes.ObjectProperty;
+    from(params: {
+        accessibility?: K.LiteralKind | null;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        shorthand?: boolean;
+        value: K.ExpressionKind | K.PatternKind;
+    }): namedTypes.ObjectProperty;
+}
+export interface PropertyPatternBuilder {
+    (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;
+    }): namedTypes.PropertyPattern;
+}
+export interface ObjectPatternBuilder {
+    (properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind | K.RestElementKind)[]): 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 | K.RestElementKind)[];
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+    }): namedTypes.ObjectPattern;
+}
+export interface ArrayPatternBuilder {
+    (elements: (K.PatternKind | K.SpreadElementKind | null)[]): namedTypes.ArrayPattern;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elements: (K.PatternKind | K.SpreadElementKind | null)[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ArrayPattern;
+}
+export interface SpreadElementBuilder {
+    (argument: K.ExpressionKind): namedTypes.SpreadElement;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SpreadElement;
+}
+export interface AssignmentPatternBuilder {
+    (left: K.PatternKind, right: K.ExpressionKind): namedTypes.AssignmentPattern;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        left: K.PatternKind;
+        loc?: K.SourceLocationKind | null;
+        right: K.ExpressionKind;
+    }): namedTypes.AssignmentPattern;
+}
+export interface MethodDefinitionBuilder {
+    (kind: "constructor" | "method" | "get" | "set", key: K.ExpressionKind, value: K.FunctionKind, staticParam?: boolean): namedTypes.MethodDefinition;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        key: K.ExpressionKind;
+        kind: "constructor" | "method" | "get" | "set";
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        value: K.FunctionKind;
+    }): namedTypes.MethodDefinition;
+}
+export interface ClassPropertyDefinitionBuilder {
+    (definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.StaticBlockKind): namedTypes.ClassPropertyDefinition;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.StaticBlockKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ClassPropertyDefinition;
+}
+export interface ClassPropertyBuilder {
+    (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;
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        value: K.ExpressionKind | null;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.ClassProperty;
+}
+export interface StaticBlockBuilder {
+    (body: K.StatementKind[]): namedTypes.StaticBlock;
+    from(params: {
+        body: K.StatementKind[];
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.StaticBlock;
+}
+export interface ClassBodyBuilder {
+    (body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassAccessorPropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.StaticBlockKind | 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.ClassAccessorPropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.StaticBlockKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ClassBody;
+}
+export interface ClassDeclarationBuilder {
+    (id: K.IdentifierKind | null, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassDeclaration;
+    from(params: {
+        body: K.ClassBodyKind;
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind | null;
+        implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[];
+        loc?: K.SourceLocationKind | null;
+        superClass?: K.ExpressionKind | null;
+        superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ClassDeclaration;
+}
+export interface ClassExpressionBuilder {
+    (id: K.IdentifierKind | null | undefined, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassExpression;
+    from(params: {
+        body: K.ClassBodyKind;
+        comments?: K.CommentKind[] | null;
+        id?: K.IdentifierKind | null;
+        implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[];
+        loc?: K.SourceLocationKind | null;
+        superClass?: K.ExpressionKind | null;
+        superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ClassExpression;
+}
+export interface SuperBuilder {
+    (): namedTypes.Super;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Super;
+}
+export interface ImportSpecifierBuilder {
+    (imported: K.IdentifierKind, local?: K.IdentifierKind | null): namedTypes.ImportSpecifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id?: K.IdentifierKind | null;
+        imported: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        local?: K.IdentifierKind | null;
+        name?: K.IdentifierKind | null;
+    }): namedTypes.ImportSpecifier;
+}
+export interface ImportDefaultSpecifierBuilder {
+    (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;
+    }): namedTypes.ImportDefaultSpecifier;
+}
+export interface ImportNamespaceSpecifierBuilder {
+    (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;
+    }): namedTypes.ImportNamespaceSpecifier;
+}
+export interface ImportDeclarationBuilder {
+    (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type" | "typeof"): namedTypes.ImportDeclaration;
+    from(params: {
+        assertions?: K.ImportAttributeKind[];
+        comments?: K.CommentKind[] | null;
+        importKind?: "value" | "type" | "typeof";
+        loc?: K.SourceLocationKind | null;
+        source: K.LiteralKind;
+        specifiers?: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[];
+    }): namedTypes.ImportDeclaration;
+}
+export interface ExportNamedDeclarationBuilder {
+    (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): namedTypes.ExportNamedDeclaration;
+    from(params: {
+        assertions?: K.ImportAttributeKind[];
+        comments?: K.CommentKind[] | null;
+        declaration: K.DeclarationKind | null;
+        loc?: K.SourceLocationKind | null;
+        source?: K.LiteralKind | null;
+        specifiers?: K.ExportSpecifierKind[];
+    }): namedTypes.ExportNamedDeclaration;
+}
+export interface ExportSpecifierBuilder {
+    (id?: K.IdentifierKind | null, name?: K.IdentifierKind | null): namedTypes.ExportSpecifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        exported: K.IdentifierKind;
+        id?: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+        local?: K.IdentifierKind | null;
+        name?: K.IdentifierKind | null;
+    }): namedTypes.ExportSpecifier;
+}
+export interface ExportDefaultDeclarationBuilder {
+    (declaration: K.DeclarationKind | K.ExpressionKind): namedTypes.ExportDefaultDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        declaration: K.DeclarationKind | K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExportDefaultDeclaration;
+}
+export interface ExportAllDeclarationBuilder {
+    (source: K.LiteralKind, exported?: K.IdentifierKind | null | undefined): namedTypes.ExportAllDeclaration;
+    from(params: {
+        assertions?: K.ImportAttributeKind[];
+        comments?: K.CommentKind[] | null;
+        exported?: K.IdentifierKind | null | undefined;
+        loc?: K.SourceLocationKind | null;
+        source: K.LiteralKind;
+    }): namedTypes.ExportAllDeclaration;
+}
+export interface TaggedTemplateExpressionBuilder {
+    (tag: K.ExpressionKind, quasi: K.TemplateLiteralKind): namedTypes.TaggedTemplateExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        quasi: K.TemplateLiteralKind;
+        tag: K.ExpressionKind;
+    }): namedTypes.TaggedTemplateExpression;
+}
+export interface TemplateLiteralBuilder {
+    (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[] | K.TSTypeKind[]): namedTypes.TemplateLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expressions: K.ExpressionKind[] | K.TSTypeKind[];
+        loc?: K.SourceLocationKind | null;
+        quasis: K.TemplateElementKind[];
+    }): namedTypes.TemplateLiteral;
+}
+export interface TemplateElementBuilder {
+    (value: {
+        cooked: string | null;
+        raw: string;
+    }, tail: boolean): namedTypes.TemplateElement;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        tail: boolean;
+        value: {
+            cooked: string | null;
+            raw: string;
+        };
+    }): namedTypes.TemplateElement;
+}
+export interface MetaPropertyBuilder {
+    (meta: K.IdentifierKind, property: K.IdentifierKind): namedTypes.MetaProperty;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        meta: K.IdentifierKind;
+        property: K.IdentifierKind;
+    }): namedTypes.MetaProperty;
+}
+export interface AwaitExpressionBuilder {
+    (argument: K.ExpressionKind | null, all?: boolean): namedTypes.AwaitExpression;
+    from(params: {
+        all?: boolean;
+        argument: K.ExpressionKind | null;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.AwaitExpression;
+}
+export interface SpreadPropertyBuilder {
+    (argument: K.ExpressionKind): namedTypes.SpreadProperty;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SpreadProperty;
+}
+export interface SpreadPropertyPatternBuilder {
+    (argument: K.PatternKind): namedTypes.SpreadPropertyPattern;
+    from(params: {
+        argument: K.PatternKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SpreadPropertyPattern;
+}
+export interface ImportExpressionBuilder {
+    (source: K.ExpressionKind): namedTypes.ImportExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        source: K.ExpressionKind;
+    }): namedTypes.ImportExpression;
+}
+export interface ChainExpressionBuilder {
+    (expression: K.ChainElementKind): namedTypes.ChainExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ChainElementKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ChainExpression;
+}
+export interface OptionalCallExpressionBuilder {
+    (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;
+        typeArguments?: null | K.TypeParameterInstantiationKind;
+    }): namedTypes.OptionalCallExpression;
+}
+export interface OptionalMemberExpressionBuilder {
+    (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        loc?: K.SourceLocationKind | null;
+        object: K.ExpressionKind;
+        optional?: boolean;
+        property: K.IdentifierKind | K.ExpressionKind;
+    }): namedTypes.OptionalMemberExpression;
+}
+export interface DecoratorBuilder {
+    (expression: K.ExpressionKind): namedTypes.Decorator;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Decorator;
+}
+export interface PrivateNameBuilder {
+    (id: K.IdentifierKind): namedTypes.PrivateName;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.PrivateName;
+}
+export interface ClassPrivatePropertyBuilder {
+    (key: K.PrivateNameKind, value?: K.ExpressionKind | null): namedTypes.ClassPrivateProperty;
+    from(params: {
+        access?: "public" | "private" | "protected" | undefined;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        key: K.PrivateNameKind;
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        value?: K.ExpressionKind | null;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.ClassPrivateProperty;
+}
+export interface ImportAttributeBuilder {
+    (key: K.IdentifierKind | K.LiteralKind, value: K.ExpressionKind): namedTypes.ImportAttribute;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        key: K.IdentifierKind | K.LiteralKind;
+        loc?: K.SourceLocationKind | null;
+        value: K.ExpressionKind;
+    }): namedTypes.ImportAttribute;
+}
+export interface RecordExpressionBuilder {
+    (properties: (K.ObjectPropertyKind | K.ObjectMethodKind | K.SpreadElementKind)[]): namedTypes.RecordExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        properties: (K.ObjectPropertyKind | K.ObjectMethodKind | K.SpreadElementKind)[];
+    }): namedTypes.RecordExpression;
+}
+export interface ObjectMethodBuilder {
+    (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
+    from(params: {
+        accessibility?: K.LiteralKind | null;
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        expression?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        kind: "method" | "get" | "set";
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ObjectMethod;
+}
+export interface TupleExpressionBuilder {
+    (elements: (K.ExpressionKind | K.SpreadElementKind | null)[]): namedTypes.TupleExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elements: (K.ExpressionKind | K.SpreadElementKind | null)[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TupleExpression;
+}
+export interface ModuleExpressionBuilder {
+    (body: K.ProgramKind): namedTypes.ModuleExpression;
+    from(params: {
+        body: K.ProgramKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ModuleExpression;
+}
+export interface JSXAttributeBuilder {
+    (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | K.JSXElementKind | K.JSXFragmentKind | null): namedTypes.JSXAttribute;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;
+        value?: K.LiteralKind | K.JSXExpressionContainerKind | K.JSXElementKind | K.JSXFragmentKind | null;
+    }): namedTypes.JSXAttribute;
+}
+export interface JSXIdentifierBuilder {
+    (name: string): namedTypes.JSXIdentifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: string;
+        optional?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+    }): namedTypes.JSXIdentifier;
+}
+export interface JSXNamespacedNameBuilder {
+    (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): namedTypes.JSXNamespacedName;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: K.JSXIdentifierKind;
+        namespace: K.JSXIdentifierKind;
+    }): namedTypes.JSXNamespacedName;
+}
+export interface JSXExpressionContainerBuilder {
+    (expression: K.ExpressionKind | K.JSXEmptyExpressionKind): namedTypes.JSXExpressionContainer;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind | K.JSXEmptyExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXExpressionContainer;
+}
+export interface JSXElementBuilder {
+    (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXTextKind | K.JSXExpressionContainerKind | K.JSXSpreadChildKind | K.JSXElementKind | K.JSXFragmentKind | K.LiteralKind)[]): namedTypes.JSXElement;
+    from(params: {
+        attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
+        children?: (K.JSXTextKind | K.JSXExpressionContainerKind | K.JSXSpreadChildKind | K.JSXElementKind | K.JSXFragmentKind | K.LiteralKind)[];
+        closingElement?: K.JSXClosingElementKind | null;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
+        openingElement: K.JSXOpeningElementKind;
+        selfClosing?: boolean;
+    }): namedTypes.JSXElement;
+}
+export interface JSXFragmentBuilder {
+    (openingFragment: K.JSXOpeningFragmentKind, closingFragment: K.JSXClosingFragmentKind, children?: (K.JSXTextKind | K.JSXExpressionContainerKind | K.JSXSpreadChildKind | K.JSXElementKind | K.JSXFragmentKind | K.LiteralKind)[]): namedTypes.JSXFragment;
+    from(params: {
+        children?: (K.JSXTextKind | K.JSXExpressionContainerKind | K.JSXSpreadChildKind | K.JSXElementKind | K.JSXFragmentKind | K.LiteralKind)[];
+        closingFragment: K.JSXClosingFragmentKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        openingFragment: K.JSXOpeningFragmentKind;
+    }): namedTypes.JSXFragment;
+}
+export interface JSXMemberExpressionBuilder {
+    (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;
+        optional?: boolean;
+        property: K.JSXIdentifierKind;
+    }): namedTypes.JSXMemberExpression;
+}
+export interface JSXSpreadAttributeBuilder {
+    (argument: K.ExpressionKind): namedTypes.JSXSpreadAttribute;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXSpreadAttribute;
+}
+export interface JSXEmptyExpressionBuilder {
+    (): namedTypes.JSXEmptyExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXEmptyExpression;
+}
+export interface JSXTextBuilder {
+    (value: string, raw?: string): namedTypes.JSXText;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw?: string;
+        value: string;
+    }): namedTypes.JSXText;
+}
+export interface JSXSpreadChildBuilder {
+    (expression: K.ExpressionKind): namedTypes.JSXSpreadChild;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXSpreadChild;
+}
+export interface JSXOpeningElementBuilder {
+    (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;
+    }): namedTypes.JSXOpeningElement;
+}
+export interface JSXClosingElementBuilder {
+    (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;
+    }): namedTypes.JSXClosingElement;
+}
+export interface JSXOpeningFragmentBuilder {
+    (): namedTypes.JSXOpeningFragment;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXOpeningFragment;
+}
+export interface JSXClosingFragmentBuilder {
+    (): namedTypes.JSXClosingFragment;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.JSXClosingFragment;
+}
+export interface TypeParameterDeclarationBuilder {
+    (params: K.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.TypeParameterKind[];
+    }): namedTypes.TypeParameterDeclaration;
+}
+export interface TSTypeParameterDeclarationBuilder {
+    (params: K.TSTypeParameterKind[]): namedTypes.TSTypeParameterDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.TSTypeParameterKind[];
+    }): namedTypes.TSTypeParameterDeclaration;
+}
+export interface TypeParameterInstantiationBuilder {
+    (params: K.FlowTypeKind[]): namedTypes.TypeParameterInstantiation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.FlowTypeKind[];
+    }): namedTypes.TypeParameterInstantiation;
+}
+export interface TSTypeParameterInstantiationBuilder {
+    (params: K.TSTypeKind[]): namedTypes.TSTypeParameterInstantiation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.TSTypeKind[];
+    }): namedTypes.TSTypeParameterInstantiation;
+}
+export interface ClassImplementsBuilder {
+    (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;
+    }): namedTypes.ClassImplements;
+}
+export interface TSExpressionWithTypeArgumentsBuilder {
+    (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;
+    }): namedTypes.TSExpressionWithTypeArguments;
+}
+export interface AnyTypeAnnotationBuilder {
+    (): namedTypes.AnyTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.AnyTypeAnnotation;
+}
+export interface EmptyTypeAnnotationBuilder {
+    (): namedTypes.EmptyTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.EmptyTypeAnnotation;
+}
+export interface MixedTypeAnnotationBuilder {
+    (): namedTypes.MixedTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.MixedTypeAnnotation;
+}
+export interface VoidTypeAnnotationBuilder {
+    (): namedTypes.VoidTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.VoidTypeAnnotation;
+}
+export interface SymbolTypeAnnotationBuilder {
+    (): namedTypes.SymbolTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.SymbolTypeAnnotation;
+}
+export interface NumberTypeAnnotationBuilder {
+    (): namedTypes.NumberTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.NumberTypeAnnotation;
+}
+export interface BigIntTypeAnnotationBuilder {
+    (): namedTypes.BigIntTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.BigIntTypeAnnotation;
+}
+export interface NumberLiteralTypeAnnotationBuilder {
+    (value: number, raw: string): namedTypes.NumberLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw: string;
+        value: number;
+    }): namedTypes.NumberLiteralTypeAnnotation;
+}
+export interface NumericLiteralTypeAnnotationBuilder {
+    (value: number, raw: string): namedTypes.NumericLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw: string;
+        value: number;
+    }): namedTypes.NumericLiteralTypeAnnotation;
+}
+export interface BigIntLiteralTypeAnnotationBuilder {
+    (value: null, raw: string): namedTypes.BigIntLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw: string;
+        value: null;
+    }): namedTypes.BigIntLiteralTypeAnnotation;
+}
+export interface StringTypeAnnotationBuilder {
+    (): namedTypes.StringTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.StringTypeAnnotation;
+}
+export interface StringLiteralTypeAnnotationBuilder {
+    (value: string, raw: string): namedTypes.StringLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw: string;
+        value: string;
+    }): namedTypes.StringLiteralTypeAnnotation;
+}
+export interface BooleanTypeAnnotationBuilder {
+    (): namedTypes.BooleanTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.BooleanTypeAnnotation;
+}
+export interface BooleanLiteralTypeAnnotationBuilder {
+    (value: boolean, raw: string): namedTypes.BooleanLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        raw: string;
+        value: boolean;
+    }): namedTypes.BooleanLiteralTypeAnnotation;
+}
+export interface NullableTypeAnnotationBuilder {
+    (typeAnnotation: K.FlowTypeKind): namedTypes.NullableTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.FlowTypeKind;
+    }): namedTypes.NullableTypeAnnotation;
+}
+export interface NullLiteralTypeAnnotationBuilder {
+    (): namedTypes.NullLiteralTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.NullLiteralTypeAnnotation;
+}
+export interface NullTypeAnnotationBuilder {
+    (): namedTypes.NullTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.NullTypeAnnotation;
+}
+export interface ThisTypeAnnotationBuilder {
+    (): namedTypes.ThisTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ThisTypeAnnotation;
+}
+export interface ExistsTypeAnnotationBuilder {
+    (): namedTypes.ExistsTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExistsTypeAnnotation;
+}
+export interface ExistentialTypeParamBuilder {
+    (): namedTypes.ExistentialTypeParam;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExistentialTypeParam;
+}
+export interface FunctionTypeAnnotationBuilder {
+    (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;
+        params: K.FunctionTypeParamKind[];
+        rest: K.FunctionTypeParamKind | null;
+        returnType: K.FlowTypeKind;
+        typeParameters: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.FunctionTypeAnnotation;
+}
+export interface FunctionTypeParamBuilder {
+    (name: K.IdentifierKind | null, typeAnnotation: K.FlowTypeKind, optional: boolean): namedTypes.FunctionTypeParam;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: K.IdentifierKind | null;
+        optional: boolean;
+        typeAnnotation: K.FlowTypeKind;
+    }): namedTypes.FunctionTypeParam;
+}
+export interface ArrayTypeAnnotationBuilder {
+    (elementType: K.FlowTypeKind): namedTypes.ArrayTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elementType: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ArrayTypeAnnotation;
+}
+export interface ObjectTypeAnnotationBuilder {
+    (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): namedTypes.ObjectTypeAnnotation;
+    from(params: {
+        callProperties?: K.ObjectTypeCallPropertyKind[];
+        comments?: K.CommentKind[] | null;
+        exact?: boolean;
+        indexers?: K.ObjectTypeIndexerKind[];
+        inexact?: boolean | undefined;
+        internalSlots?: K.ObjectTypeInternalSlotKind[];
+        loc?: K.SourceLocationKind | null;
+        properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[];
+    }): namedTypes.ObjectTypeAnnotation;
+}
+export interface ObjectTypePropertyBuilder {
+    (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): namedTypes.ObjectTypeProperty;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        key: K.LiteralKind | K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        optional: boolean;
+        value: K.FlowTypeKind;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.ObjectTypeProperty;
+}
+export interface ObjectTypeSpreadPropertyBuilder {
+    (argument: K.FlowTypeKind): namedTypes.ObjectTypeSpreadProperty;
+    from(params: {
+        argument: K.FlowTypeKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ObjectTypeSpreadProperty;
+}
+export interface ObjectTypeIndexerBuilder {
+    (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): namedTypes.ObjectTypeIndexer;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        key: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        value: K.FlowTypeKind;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.ObjectTypeIndexer;
+}
+export interface ObjectTypeCallPropertyBuilder {
+    (value: K.FunctionTypeAnnotationKind): namedTypes.ObjectTypeCallProperty;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        static?: boolean;
+        value: K.FunctionTypeAnnotationKind;
+    }): namedTypes.ObjectTypeCallProperty;
+}
+export interface ObjectTypeInternalSlotBuilder {
+    (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): namedTypes.ObjectTypeInternalSlot;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        method: boolean;
+        optional: boolean;
+        static: boolean;
+        value: K.FlowTypeKind;
+    }): namedTypes.ObjectTypeInternalSlot;
+}
+export interface VarianceBuilder {
+    (kind: "plus" | "minus"): namedTypes.Variance;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        kind: "plus" | "minus";
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Variance;
+}
+export interface QualifiedTypeIdentifierBuilder {
+    (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;
+    }): namedTypes.QualifiedTypeIdentifier;
+}
+export interface GenericTypeAnnotationBuilder {
+    (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;
+    }): namedTypes.GenericTypeAnnotation;
+}
+export interface MemberTypeAnnotationBuilder {
+    (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;
+    }): namedTypes.MemberTypeAnnotation;
+}
+export interface IndexedAccessTypeBuilder {
+    (objectType: K.FlowTypeKind, indexType: K.FlowTypeKind): namedTypes.IndexedAccessType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        indexType: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        objectType: K.FlowTypeKind;
+    }): namedTypes.IndexedAccessType;
+}
+export interface OptionalIndexedAccessTypeBuilder {
+    (objectType: K.FlowTypeKind, indexType: K.FlowTypeKind, optional: boolean): namedTypes.OptionalIndexedAccessType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        indexType: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        objectType: K.FlowTypeKind;
+        optional: boolean;
+    }): namedTypes.OptionalIndexedAccessType;
+}
+export interface UnionTypeAnnotationBuilder {
+    (types: K.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        types: K.FlowTypeKind[];
+    }): namedTypes.UnionTypeAnnotation;
+}
+export interface IntersectionTypeAnnotationBuilder {
+    (types: K.FlowTypeKind[]): namedTypes.IntersectionTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        types: K.FlowTypeKind[];
+    }): namedTypes.IntersectionTypeAnnotation;
+}
+export interface TypeofTypeAnnotationBuilder {
+    (argument: K.FlowTypeKind): namedTypes.TypeofTypeAnnotation;
+    from(params: {
+        argument: K.FlowTypeKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TypeofTypeAnnotation;
+}
+export interface TypeParameterBuilder {
+    (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null, defaultParam?: K.FlowTypeKind | null): namedTypes.TypeParameter;
+    from(params: {
+        bound?: K.TypeAnnotationKind | null;
+        comments?: K.CommentKind[] | null;
+        default?: K.FlowTypeKind | null;
+        loc?: K.SourceLocationKind | null;
+        name: string;
+        variance?: K.VarianceKind | "plus" | "minus" | null;
+    }): namedTypes.TypeParameter;
+}
+export interface InterfaceTypeAnnotationBuilder {
+    (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;
+    }): namedTypes.InterfaceTypeAnnotation;
+}
+export interface InterfaceExtendsBuilder {
+    (id: K.IdentifierKind): namedTypes.InterfaceExtends;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TypeParameterInstantiationKind | null;
+    }): namedTypes.InterfaceExtends;
+}
+export interface InterfaceDeclarationBuilder {
+    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.InterfaceDeclaration;
+    from(params: {
+        body: K.ObjectTypeAnnotationKind;
+        comments?: K.CommentKind[] | null;
+        extends: K.InterfaceExtendsKind[];
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.InterfaceDeclaration;
+}
+export interface DeclareInterfaceBuilder {
+    (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.DeclareInterface;
+    from(params: {
+        body: K.ObjectTypeAnnotationKind;
+        comments?: K.CommentKind[] | null;
+        extends: K.InterfaceExtendsKind[];
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.DeclareInterface;
+}
+export interface TypeAliasBuilder {
+    (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;
+    }): namedTypes.TypeAlias;
+}
+export interface DeclareTypeAliasBuilder {
+    (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;
+    }): namedTypes.DeclareTypeAlias;
+}
+export interface OpaqueTypeBuilder {
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind | null): namedTypes.OpaqueType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        impltype: K.FlowTypeKind;
+        loc?: K.SourceLocationKind | null;
+        supertype: K.FlowTypeKind | null;
+        typeParameters: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.OpaqueType;
+}
+export interface DeclareOpaqueTypeBuilder {
+    (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, supertype: K.FlowTypeKind | null): namedTypes.DeclareOpaqueType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        impltype: K.FlowTypeKind | null;
+        loc?: K.SourceLocationKind | null;
+        supertype: K.FlowTypeKind | null;
+        typeParameters: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.DeclareOpaqueType;
+}
+export interface TypeCastExpressionBuilder {
+    (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): namedTypes.TypeCastExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TypeAnnotationKind;
+    }): namedTypes.TypeCastExpression;
+}
+export interface TupleTypeAnnotationBuilder {
+    (types: K.FlowTypeKind[]): namedTypes.TupleTypeAnnotation;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        types: K.FlowTypeKind[];
+    }): namedTypes.TupleTypeAnnotation;
+}
+export interface DeclareVariableBuilder {
+    (id: K.IdentifierKind): namedTypes.DeclareVariable;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.DeclareVariable;
+}
+export interface DeclareFunctionBuilder {
+    (id: K.IdentifierKind): namedTypes.DeclareFunction;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        predicate?: K.FlowPredicateKind | null;
+    }): namedTypes.DeclareFunction;
+}
+export interface DeclareClassBuilder {
+    (id: K.IdentifierKind): namedTypes.DeclareClass;
+    from(params: {
+        body: K.ObjectTypeAnnotationKind;
+        comments?: K.CommentKind[] | null;
+        extends: K.InterfaceExtendsKind[];
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TypeParameterDeclarationKind | null;
+    }): namedTypes.DeclareClass;
+}
+export interface DeclareModuleBuilder {
+    (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;
+    }): namedTypes.DeclareModule;
+}
+export interface DeclareModuleExportsBuilder {
+    (typeAnnotation: K.TypeAnnotationKind): namedTypes.DeclareModuleExports;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TypeAnnotationKind;
+    }): namedTypes.DeclareModuleExports;
+}
+export interface DeclareExportDeclarationBuilder {
+    (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | K.TypeAliasKind | K.DeclareOpaqueTypeKind | K.InterfaceDeclarationKind | 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 | K.TypeAliasKind | K.DeclareOpaqueTypeKind | K.InterfaceDeclarationKind | null;
+        default: boolean;
+        loc?: K.SourceLocationKind | null;
+        source?: K.LiteralKind | null;
+        specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
+    }): namedTypes.DeclareExportDeclaration;
+}
+export interface ExportBatchSpecifierBuilder {
+    (): namedTypes.ExportBatchSpecifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExportBatchSpecifier;
+}
+export interface DeclareExportAllDeclarationBuilder {
+    (source?: K.LiteralKind | null): namedTypes.DeclareExportAllDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        source?: K.LiteralKind | null;
+    }): namedTypes.DeclareExportAllDeclaration;
+}
+export interface InferredPredicateBuilder {
+    (): namedTypes.InferredPredicate;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.InferredPredicate;
+}
+export interface DeclaredPredicateBuilder {
+    (value: K.ExpressionKind): namedTypes.DeclaredPredicate;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value: K.ExpressionKind;
+    }): namedTypes.DeclaredPredicate;
+}
+export interface EnumDeclarationBuilder {
+    (id: K.IdentifierKind, body: K.EnumBooleanBodyKind | K.EnumNumberBodyKind | K.EnumStringBodyKind | K.EnumSymbolBodyKind): namedTypes.EnumDeclaration;
+    from(params: {
+        body: K.EnumBooleanBodyKind | K.EnumNumberBodyKind | K.EnumStringBodyKind | K.EnumSymbolBodyKind;
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.EnumDeclaration;
+}
+export interface EnumBooleanBodyBuilder {
+    (members: K.EnumBooleanMemberKind[], explicitType: boolean): namedTypes.EnumBooleanBody;
+    from(params: {
+        explicitType: boolean;
+        members: K.EnumBooleanMemberKind[];
+    }): namedTypes.EnumBooleanBody;
+}
+export interface EnumNumberBodyBuilder {
+    (members: K.EnumNumberMemberKind[], explicitType: boolean): namedTypes.EnumNumberBody;
+    from(params: {
+        explicitType: boolean;
+        members: K.EnumNumberMemberKind[];
+    }): namedTypes.EnumNumberBody;
+}
+export interface EnumStringBodyBuilder {
+    (members: K.EnumStringMemberKind[] | K.EnumDefaultedMemberKind[], explicitType: boolean): namedTypes.EnumStringBody;
+    from(params: {
+        explicitType: boolean;
+        members: K.EnumStringMemberKind[] | K.EnumDefaultedMemberKind[];
+    }): namedTypes.EnumStringBody;
+}
+export interface EnumSymbolBodyBuilder {
+    (members: K.EnumDefaultedMemberKind[]): namedTypes.EnumSymbolBody;
+    from(params: {
+        members: K.EnumDefaultedMemberKind[];
+    }): namedTypes.EnumSymbolBody;
+}
+export interface EnumBooleanMemberBuilder {
+    (id: K.IdentifierKind, init: K.LiteralKind | boolean): namedTypes.EnumBooleanMember;
+    from(params: {
+        id: K.IdentifierKind;
+        init: K.LiteralKind | boolean;
+    }): namedTypes.EnumBooleanMember;
+}
+export interface EnumNumberMemberBuilder {
+    (id: K.IdentifierKind, init: K.LiteralKind): namedTypes.EnumNumberMember;
+    from(params: {
+        id: K.IdentifierKind;
+        init: K.LiteralKind;
+    }): namedTypes.EnumNumberMember;
+}
+export interface EnumStringMemberBuilder {
+    (id: K.IdentifierKind, init: K.LiteralKind): namedTypes.EnumStringMember;
+    from(params: {
+        id: K.IdentifierKind;
+        init: K.LiteralKind;
+    }): namedTypes.EnumStringMember;
+}
+export interface EnumDefaultedMemberBuilder {
+    (id: K.IdentifierKind): namedTypes.EnumDefaultedMember;
+    from(params: {
+        id: K.IdentifierKind;
+    }): namedTypes.EnumDefaultedMember;
+}
+export interface ExportDeclarationBuilder {
+    (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;
+        default: boolean;
+        loc?: K.SourceLocationKind | null;
+        source?: K.LiteralKind | null;
+        specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
+    }): namedTypes.ExportDeclaration;
+}
+export interface BlockBuilder {
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Block;
+    from(params: {
+        leading?: boolean;
+        loc?: K.SourceLocationKind | null;
+        trailing?: boolean;
+        value: string;
+    }): namedTypes.Block;
+}
+export interface LineBuilder {
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Line;
+    from(params: {
+        leading?: boolean;
+        loc?: K.SourceLocationKind | null;
+        trailing?: boolean;
+        value: string;
+    }): namedTypes.Line;
+}
+export interface NoopBuilder {
+    (): namedTypes.Noop;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Noop;
+}
+export interface DoExpressionBuilder {
+    (body: K.StatementKind[]): namedTypes.DoExpression;
+    from(params: {
+        body: K.StatementKind[];
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.DoExpression;
+}
+export interface BindExpressionBuilder {
+    (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;
+    }): namedTypes.BindExpression;
+}
+export interface ParenthesizedExpressionBuilder {
+    (expression: K.ExpressionKind): namedTypes.ParenthesizedExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ParenthesizedExpression;
+}
+export interface ExportNamespaceSpecifierBuilder {
+    (exported: K.IdentifierKind): namedTypes.ExportNamespaceSpecifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        exported: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExportNamespaceSpecifier;
+}
+export interface ExportDefaultSpecifierBuilder {
+    (exported: K.IdentifierKind): namedTypes.ExportDefaultSpecifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        exported: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.ExportDefaultSpecifier;
+}
+export interface CommentBlockBuilder {
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentBlock;
+    from(params: {
+        leading?: boolean;
+        loc?: K.SourceLocationKind | null;
+        trailing?: boolean;
+        value: string;
+    }): namedTypes.CommentBlock;
+}
+export interface CommentLineBuilder {
+    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentLine;
+    from(params: {
+        leading?: boolean;
+        loc?: K.SourceLocationKind | null;
+        trailing?: boolean;
+        value: string;
+    }): namedTypes.CommentLine;
+}
+export interface DirectiveBuilder {
+    (value: K.DirectiveLiteralKind): namedTypes.Directive;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value: K.DirectiveLiteralKind;
+    }): namedTypes.Directive;
+}
+export interface DirectiveLiteralBuilder {
+    (value?: string): namedTypes.DirectiveLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value?: string;
+    }): namedTypes.DirectiveLiteral;
+}
+export interface InterpreterDirectiveBuilder {
+    (value: string): namedTypes.InterpreterDirective;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value: string;
+    }): namedTypes.InterpreterDirective;
+}
+export interface StringLiteralBuilder {
+    (value: string): namedTypes.StringLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
+        loc?: K.SourceLocationKind | null;
+        value: string;
+    }): namedTypes.StringLiteral;
+}
+export interface NumericLiteralBuilder {
+    (value: number): namedTypes.NumericLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: number;
+            raw: string;
+        };
+        loc?: K.SourceLocationKind | null;
+        raw?: string | null;
+        value: number;
+    }): namedTypes.NumericLiteral;
+}
+export interface BigIntLiteralBuilder {
+    (value: string | number): namedTypes.BigIntLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
+        loc?: K.SourceLocationKind | null;
+        value: string | number;
+    }): namedTypes.BigIntLiteral;
+}
+export interface DecimalLiteralBuilder {
+    (value: string): namedTypes.DecimalLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: string;
+            raw: string;
+        };
+        loc?: K.SourceLocationKind | null;
+        value: string;
+    }): namedTypes.DecimalLiteral;
+}
+export interface NullLiteralBuilder {
+    (): namedTypes.NullLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value?: null;
+    }): namedTypes.NullLiteral;
+}
+export interface BooleanLiteralBuilder {
+    (value: boolean): namedTypes.BooleanLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        value: boolean;
+    }): namedTypes.BooleanLiteral;
+}
+export interface RegExpLiteralBuilder {
+    (pattern: string, flags: string): namedTypes.RegExpLiteral;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        extra?: {
+            rawValue: RegExp | undefined;
+            raw: string;
+        };
+        flags: string;
+        loc?: K.SourceLocationKind | null;
+        pattern: string;
+        regex?: {
+            pattern: string;
+            flags: string;
+        };
+        value?: RegExp;
+    }): namedTypes.RegExpLiteral;
+}
+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): namedTypes.ClassMethod;
+    from(params: {
+        abstract?: boolean;
+        access?: "public" | "private" | "protected" | null;
+        accessibility?: "public" | "private" | "protected" | null;
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        definite?: boolean;
+        expression?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
+        kind?: "get" | "set" | "method" | "constructor";
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+        override?: boolean;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        readonly?: boolean;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        static?: boolean;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ClassMethod;
+}
+export interface ClassPrivateMethodBuilder {
+    (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean): namedTypes.ClassPrivateMethod;
+    from(params: {
+        abstract?: boolean;
+        access?: "public" | "private" | "protected" | null;
+        accessibility?: "public" | "private" | "protected" | null;
+        async?: boolean;
+        body: K.BlockStatementKind;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        defaults?: (K.ExpressionKind | null)[];
+        definite?: boolean;
+        expression?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        key: K.PrivateNameKind;
+        kind?: "get" | "set" | "method" | "constructor";
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+        override?: boolean;
+        params: K.PatternKind[];
+        predicate?: K.FlowPredicateKind | null;
+        readonly?: boolean;
+        rest?: K.IdentifierKind | null;
+        returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+        static?: boolean;
+        typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
+    }): namedTypes.ClassPrivateMethod;
+}
+export interface ClassAccessorPropertyBuilder {
+    (key: K.LiteralKind | K.IdentifierKind | K.PrivateNameKind | K.ExpressionKind, value?: K.ExpressionKind | null, decorators?: K.DecoratorKind[] | null, computed?: boolean, staticParam?: boolean): namedTypes.ClassAccessorProperty;
+    from(params: {
+        abstract?: boolean;
+        accessibility?: "public" | "private" | "protected" | null;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        definite?: boolean;
+        key: K.LiteralKind | K.IdentifierKind | K.PrivateNameKind | K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+        override?: boolean;
+        readonly?: boolean;
+        static?: boolean;
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        value?: K.ExpressionKind | null;
+    }): namedTypes.ClassAccessorProperty;
+}
+export interface RestPropertyBuilder {
+    (argument: K.ExpressionKind): namedTypes.RestProperty;
+    from(params: {
+        argument: K.ExpressionKind;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.RestProperty;
+}
+export interface ForAwaitStatementBuilder {
+    (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;
+    }): namedTypes.ForAwaitStatement;
+}
+export interface ImportBuilder {
+    (): namedTypes.Import;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.Import;
+}
+export interface V8IntrinsicIdentifierBuilder {
+    (name: string): namedTypes.V8IntrinsicIdentifier;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        name: string;
+    }): namedTypes.V8IntrinsicIdentifier;
+}
+export interface TopicReferenceBuilder {
+    (): namedTypes.TopicReference;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TopicReference;
+}
+export interface TSQualifiedNameBuilder {
+    (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): namedTypes.TSQualifiedName;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        left: K.IdentifierKind | K.TSQualifiedNameKind;
+        loc?: K.SourceLocationKind | null;
+        right: K.IdentifierKind | K.TSQualifiedNameKind;
+    }): namedTypes.TSQualifiedName;
+}
+export interface TSTypeReferenceBuilder {
+    (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;
+    }): namedTypes.TSTypeReference;
+}
+export interface TSAsExpressionBuilder {
+    (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSAsExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        extra?: {
+            parenthesized: boolean;
+        } | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSAsExpression;
+}
+export interface TSTypeCastExpressionBuilder {
+    (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSTypeCastExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSTypeCastExpression;
+}
+export interface TSSatisfiesExpressionBuilder {
+    (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSSatisfiesExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSSatisfiesExpression;
+}
+export interface TSNonNullExpressionBuilder {
+    (expression: K.ExpressionKind): namedTypes.TSNonNullExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSNonNullExpression;
+}
+export interface TSAnyKeywordBuilder {
+    (): namedTypes.TSAnyKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSAnyKeyword;
+}
+export interface TSBigIntKeywordBuilder {
+    (): namedTypes.TSBigIntKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSBigIntKeyword;
+}
+export interface TSBooleanKeywordBuilder {
+    (): namedTypes.TSBooleanKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSBooleanKeyword;
+}
+export interface TSNeverKeywordBuilder {
+    (): namedTypes.TSNeverKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSNeverKeyword;
+}
+export interface TSNullKeywordBuilder {
+    (): namedTypes.TSNullKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSNullKeyword;
+}
+export interface TSNumberKeywordBuilder {
+    (): namedTypes.TSNumberKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSNumberKeyword;
+}
+export interface TSObjectKeywordBuilder {
+    (): namedTypes.TSObjectKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSObjectKeyword;
+}
+export interface TSStringKeywordBuilder {
+    (): namedTypes.TSStringKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSStringKeyword;
+}
+export interface TSSymbolKeywordBuilder {
+    (): namedTypes.TSSymbolKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSSymbolKeyword;
+}
+export interface TSUndefinedKeywordBuilder {
+    (): namedTypes.TSUndefinedKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSUndefinedKeyword;
+}
+export interface TSUnknownKeywordBuilder {
+    (): namedTypes.TSUnknownKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSUnknownKeyword;
+}
+export interface TSVoidKeywordBuilder {
+    (): namedTypes.TSVoidKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSVoidKeyword;
+}
+export interface TSIntrinsicKeywordBuilder {
+    (): namedTypes.TSIntrinsicKeyword;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSIntrinsicKeyword;
+}
+export interface TSThisTypeBuilder {
+    (): namedTypes.TSThisType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSThisType;
+}
+export interface TSArrayTypeBuilder {
+    (elementType: K.TSTypeKind): namedTypes.TSArrayType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elementType: K.TSTypeKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSArrayType;
+}
+export interface TSLiteralTypeBuilder {
+    (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind | K.BigIntLiteralKind): namedTypes.TSLiteralType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind | K.BigIntLiteralKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSLiteralType;
+}
+export interface TSUnionTypeBuilder {
+    (types: K.TSTypeKind[]): namedTypes.TSUnionType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        types: K.TSTypeKind[];
+    }): namedTypes.TSUnionType;
+}
+export interface TSIntersectionTypeBuilder {
+    (types: K.TSTypeKind[]): namedTypes.TSIntersectionType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        types: K.TSTypeKind[];
+    }): namedTypes.TSIntersectionType;
+}
+export interface TSConditionalTypeBuilder {
+    (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): namedTypes.TSConditionalType;
+    from(params: {
+        checkType: K.TSTypeKind;
+        comments?: K.CommentKind[] | null;
+        extendsType: K.TSTypeKind;
+        falseType: K.TSTypeKind;
+        loc?: K.SourceLocationKind | null;
+        trueType: K.TSTypeKind;
+    }): namedTypes.TSConditionalType;
+}
+export interface TSInferTypeBuilder {
+    (typeParameter: K.TSTypeParameterKind): namedTypes.TSInferType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeParameter: K.TSTypeParameterKind;
+    }): namedTypes.TSInferType;
+}
+export interface TSTypeParameterBuilder {
+    (name: K.IdentifierKind | string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): namedTypes.TSTypeParameter;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        constraint?: K.TSTypeKind | undefined;
+        default?: K.TSTypeKind | undefined;
+        loc?: K.SourceLocationKind | null;
+        name: K.IdentifierKind | string;
+        optional?: boolean;
+        typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
+    }): namedTypes.TSTypeParameter;
+}
+export interface TSParenthesizedTypeBuilder {
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSParenthesizedType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSParenthesizedType;
+}
+export interface TSFunctionTypeBuilder {
+    (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.ArrayPatternKind | K.ObjectPatternKind)[];
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSFunctionType;
+}
+export interface TSConstructorTypeBuilder {
+    (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.ArrayPatternKind | K.ObjectPatternKind)[];
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSConstructorType;
+}
+export interface TSDeclareFunctionBuilder {
+    (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareFunction;
+    from(params: {
+        async?: boolean;
+        comments?: K.CommentKind[] | null;
+        declare?: boolean;
+        generator?: boolean;
+        id?: K.IdentifierKind | null;
+        loc?: K.SourceLocationKind | null;
+        params: K.PatternKind[];
+        returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSDeclareFunction;
+}
+export interface TSDeclareMethodBuilder {
+    (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;
+        accessibility?: "public" | "private" | "protected" | undefined;
+        async?: boolean;
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        decorators?: K.DecoratorKind[] | null;
+        generator?: boolean;
+        key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind;
+        kind?: "get" | "set" | "method" | "constructor";
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+        params: K.PatternKind[];
+        returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
+        static?: boolean;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSDeclareMethod;
+}
+export interface TSMappedTypeBuilder {
+    (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): namedTypes.TSMappedType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean | "+" | "-";
+        readonly?: boolean | "+" | "-";
+        typeAnnotation?: K.TSTypeKind | null;
+        typeParameter: K.TSTypeParameterKind;
+    }): namedTypes.TSMappedType;
+}
+export interface TSTupleTypeBuilder {
+    (elementTypes: (K.TSTypeKind | K.TSNamedTupleMemberKind)[]): namedTypes.TSTupleType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elementTypes: (K.TSTypeKind | K.TSNamedTupleMemberKind)[];
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSTupleType;
+}
+export interface TSNamedTupleMemberBuilder {
+    (label: K.IdentifierKind, elementType: K.TSTypeKind, optional?: boolean): namedTypes.TSNamedTupleMember;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        elementType: K.TSTypeKind;
+        label: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+    }): namedTypes.TSNamedTupleMember;
+}
+export interface TSRestTypeBuilder {
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSRestType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSRestType;
+}
+export interface TSOptionalTypeBuilder {
+    (typeAnnotation: K.TSTypeKind): namedTypes.TSOptionalType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSOptionalType;
+}
+export interface TSIndexedAccessTypeBuilder {
+    (objectType: K.TSTypeKind, indexType: K.TSTypeKind): namedTypes.TSIndexedAccessType;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        indexType: K.TSTypeKind;
+        loc?: K.SourceLocationKind | null;
+        objectType: K.TSTypeKind;
+    }): namedTypes.TSIndexedAccessType;
+}
+export interface TSTypeOperatorBuilder {
+    (operator: string): namedTypes.TSTypeOperator;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        operator: string;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSTypeOperator;
+}
+export interface TSIndexSignatureBuilder {
+    (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;
+    }): namedTypes.TSIndexSignature;
+}
+export interface TSPropertySignatureBuilder {
+    (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): namedTypes.TSPropertySignature;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        computed?: boolean;
+        initializer?: K.ExpressionKind | null;
+        key: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        optional?: boolean;
+        readonly?: boolean;
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+    }): namedTypes.TSPropertySignature;
+}
+export interface TSMethodSignatureBuilder {
+    (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.ArrayPatternKind | K.ObjectPatternKind)[];
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSMethodSignature;
+}
+export interface TSTypePredicateBuilder {
+    (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation?: K.TSTypeAnnotationKind | null, asserts?: boolean): namedTypes.TSTypePredicate;
+    from(params: {
+        asserts?: boolean;
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+        parameterName: K.IdentifierKind | K.TSThisTypeKind;
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+    }): namedTypes.TSTypePredicate;
+}
+export interface TSCallSignatureDeclarationBuilder {
+    (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.ArrayPatternKind | K.ObjectPatternKind)[];
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSCallSignatureDeclaration;
+}
+export interface TSConstructSignatureDeclarationBuilder {
+    (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.ArrayPatternKind | K.ObjectPatternKind)[];
+        typeAnnotation?: K.TSTypeAnnotationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSConstructSignatureDeclaration;
+}
+export interface TSEnumMemberBuilder {
+    (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;
+    }): namedTypes.TSEnumMember;
+}
+export interface TSTypeQueryBuilder {
+    (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;
+    }): namedTypes.TSTypeQuery;
+}
+export interface TSImportTypeBuilder {
+    (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;
+    }): namedTypes.TSImportType;
+}
+export interface TSTypeLiteralBuilder {
+    (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)[];
+    }): namedTypes.TSTypeLiteral;
+}
+export interface TSTypeAssertionBuilder {
+    (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): namedTypes.TSTypeAssertion;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        extra?: {
+            parenthesized: boolean;
+        } | null;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+    }): namedTypes.TSTypeAssertion;
+}
+export interface TSInstantiationExpressionBuilder {
+    (expression: K.ExpressionKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSInstantiationExpression;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TSTypeParameterInstantiationKind | null;
+    }): namedTypes.TSInstantiationExpression;
+}
+export interface TSEnumDeclarationBuilder {
+    (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): namedTypes.TSEnumDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        const?: boolean;
+        declare?: boolean;
+        id: K.IdentifierKind;
+        initializer?: K.ExpressionKind | null;
+        loc?: K.SourceLocationKind | null;
+        members: K.TSEnumMemberKind[];
+    }): namedTypes.TSEnumDeclaration;
+}
+export interface TSTypeAliasDeclarationBuilder {
+    (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): namedTypes.TSTypeAliasDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        declare?: boolean;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+        typeAnnotation: K.TSTypeKind;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSTypeAliasDeclaration;
+}
+export interface TSModuleBlockBuilder {
+    (body: K.StatementKind[]): namedTypes.TSModuleBlock;
+    from(params: {
+        body: K.StatementKind[];
+        comments?: K.CommentKind[] | null;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSModuleBlock;
+}
+export interface TSModuleDeclarationBuilder {
+    (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;
+        declare?: boolean;
+        global?: boolean;
+        id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSModuleDeclaration;
+}
+export interface TSImportEqualsDeclarationBuilder {
+    (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;
+    }): namedTypes.TSImportEqualsDeclaration;
+}
+export interface TSExternalModuleReferenceBuilder {
+    (expression: K.StringLiteralKind): namedTypes.TSExternalModuleReference;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.StringLiteralKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSExternalModuleReference;
+}
+export interface TSExportAssignmentBuilder {
+    (expression: K.ExpressionKind): namedTypes.TSExportAssignment;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        expression: K.ExpressionKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSExportAssignment;
+}
+export interface TSNamespaceExportDeclarationBuilder {
+    (id: K.IdentifierKind): namedTypes.TSNamespaceExportDeclaration;
+    from(params: {
+        comments?: K.CommentKind[] | null;
+        id: K.IdentifierKind;
+        loc?: K.SourceLocationKind | null;
+    }): namedTypes.TSNamespaceExportDeclaration;
+}
+export interface TSInterfaceBodyBuilder {
+    (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;
+    }): namedTypes.TSInterfaceBody;
+}
+export interface TSInterfaceDeclarationBuilder {
+    (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): namedTypes.TSInterfaceDeclaration;
+    from(params: {
+        body: K.TSInterfaceBodyKind;
+        comments?: K.CommentKind[] | null;
+        declare?: boolean;
+        extends?: K.TSExpressionWithTypeArgumentsKind[] | null;
+        id: K.IdentifierKind | K.TSQualifiedNameKind;
+        loc?: K.SourceLocationKind | null;
+        typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
+    }): namedTypes.TSInterfaceDeclaration;
+}
+export interface TSParameterPropertyBuilder {
+    (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;
+    }): namedTypes.TSParameterProperty;
+}
+export interface builders {
+    file: FileBuilder;
+    program: ProgramBuilder;
+    identifier: IdentifierBuilder;
+    blockStatement: BlockStatementBuilder;
+    emptyStatement: EmptyStatementBuilder;
+    expressionStatement: ExpressionStatementBuilder;
+    ifStatement: IfStatementBuilder;
+    labeledStatement: LabeledStatementBuilder;
+    breakStatement: BreakStatementBuilder;
+    continueStatement: ContinueStatementBuilder;
+    withStatement: WithStatementBuilder;
+    switchStatement: SwitchStatementBuilder;
+    switchCase: SwitchCaseBuilder;
+    returnStatement: ReturnStatementBuilder;
+    throwStatement: ThrowStatementBuilder;
+    tryStatement: TryStatementBuilder;
+    catchClause: CatchClauseBuilder;
+    whileStatement: WhileStatementBuilder;
+    doWhileStatement: DoWhileStatementBuilder;
+    forStatement: ForStatementBuilder;
+    variableDeclaration: VariableDeclarationBuilder;
+    forInStatement: ForInStatementBuilder;
+    debuggerStatement: DebuggerStatementBuilder;
+    functionDeclaration: FunctionDeclarationBuilder;
+    functionExpression: FunctionExpressionBuilder;
+    variableDeclarator: VariableDeclaratorBuilder;
+    thisExpression: ThisExpressionBuilder;
+    arrayExpression: ArrayExpressionBuilder;
+    objectExpression: ObjectExpressionBuilder;
+    property: PropertyBuilder;
+    literal: LiteralBuilder;
+    sequenceExpression: SequenceExpressionBuilder;
+    unaryExpression: UnaryExpressionBuilder;
+    binaryExpression: BinaryExpressionBuilder;
+    assignmentExpression: AssignmentExpressionBuilder;
+    memberExpression: MemberExpressionBuilder;
+    updateExpression: UpdateExpressionBuilder;
+    logicalExpression: LogicalExpressionBuilder;
+    conditionalExpression: ConditionalExpressionBuilder;
+    newExpression: NewExpressionBuilder;
+    callExpression: CallExpressionBuilder;
+    restElement: RestElementBuilder;
+    typeAnnotation: TypeAnnotationBuilder;
+    tsTypeAnnotation: TSTypeAnnotationBuilder;
+    spreadElementPattern: SpreadElementPatternBuilder;
+    arrowFunctionExpression: ArrowFunctionExpressionBuilder;
+    forOfStatement: ForOfStatementBuilder;
+    yieldExpression: YieldExpressionBuilder;
+    generatorExpression: GeneratorExpressionBuilder;
+    comprehensionBlock: ComprehensionBlockBuilder;
+    comprehensionExpression: ComprehensionExpressionBuilder;
+    objectProperty: ObjectPropertyBuilder;
+    propertyPattern: PropertyPatternBuilder;
+    objectPattern: ObjectPatternBuilder;
+    arrayPattern: ArrayPatternBuilder;
+    spreadElement: SpreadElementBuilder;
+    assignmentPattern: AssignmentPatternBuilder;
+    methodDefinition: MethodDefinitionBuilder;
+    classPropertyDefinition: ClassPropertyDefinitionBuilder;
+    classProperty: ClassPropertyBuilder;
+    staticBlock: StaticBlockBuilder;
+    classBody: ClassBodyBuilder;
+    classDeclaration: ClassDeclarationBuilder;
+    classExpression: ClassExpressionBuilder;
+    super: SuperBuilder;
+    importSpecifier: ImportSpecifierBuilder;
+    importDefaultSpecifier: ImportDefaultSpecifierBuilder;
+    importNamespaceSpecifier: ImportNamespaceSpecifierBuilder;
+    importDeclaration: ImportDeclarationBuilder;
+    exportNamedDeclaration: ExportNamedDeclarationBuilder;
+    exportSpecifier: ExportSpecifierBuilder;
+    exportDefaultDeclaration: ExportDefaultDeclarationBuilder;
+    exportAllDeclaration: ExportAllDeclarationBuilder;
+    taggedTemplateExpression: TaggedTemplateExpressionBuilder;
+    templateLiteral: TemplateLiteralBuilder;
+    templateElement: TemplateElementBuilder;
+    metaProperty: MetaPropertyBuilder;
+    awaitExpression: AwaitExpressionBuilder;
+    spreadProperty: SpreadPropertyBuilder;
+    spreadPropertyPattern: SpreadPropertyPatternBuilder;
+    importExpression: ImportExpressionBuilder;
+    chainExpression: ChainExpressionBuilder;
+    optionalCallExpression: OptionalCallExpressionBuilder;
+    optionalMemberExpression: OptionalMemberExpressionBuilder;
+    decorator: DecoratorBuilder;
+    privateName: PrivateNameBuilder;
+    classPrivateProperty: ClassPrivatePropertyBuilder;
+    importAttribute: ImportAttributeBuilder;
+    recordExpression: RecordExpressionBuilder;
+    objectMethod: ObjectMethodBuilder;
+    tupleExpression: TupleExpressionBuilder;
+    moduleExpression: ModuleExpressionBuilder;
+    jsxAttribute: JSXAttributeBuilder;
+    jsxIdentifier: JSXIdentifierBuilder;
+    jsxNamespacedName: JSXNamespacedNameBuilder;
+    jsxExpressionContainer: JSXExpressionContainerBuilder;
+    jsxElement: JSXElementBuilder;
+    jsxFragment: JSXFragmentBuilder;
+    jsxMemberExpression: JSXMemberExpressionBuilder;
+    jsxSpreadAttribute: JSXSpreadAttributeBuilder;
+    jsxEmptyExpression: JSXEmptyExpressionBuilder;
+    jsxText: JSXTextBuilder;
+    jsxSpreadChild: JSXSpreadChildBuilder;
+    jsxOpeningElement: JSXOpeningElementBuilder;
+    jsxClosingElement: JSXClosingElementBuilder;
+    jsxOpeningFragment: JSXOpeningFragmentBuilder;
+    jsxClosingFragment: JSXClosingFragmentBuilder;
+    typeParameterDeclaration: TypeParameterDeclarationBuilder;
+    tsTypeParameterDeclaration: TSTypeParameterDeclarationBuilder;
+    typeParameterInstantiation: TypeParameterInstantiationBuilder;
+    tsTypeParameterInstantiation: TSTypeParameterInstantiationBuilder;
+    classImplements: ClassImplementsBuilder;
+    tsExpressionWithTypeArguments: TSExpressionWithTypeArgumentsBuilder;
+    anyTypeAnnotation: AnyTypeAnnotationBuilder;
+    emptyTypeAnnotation: EmptyTypeAnnotationBuilder;
+    mixedTypeAnnotation: MixedTypeAnnotationBuilder;
+    voidTypeAnnotation: VoidTypeAnnotationBuilder;
+    symbolTypeAnnotation: SymbolTypeAnnotationBuilder;
+    numberTypeAnnotation: NumberTypeAnnotationBuilder;
+    bigIntTypeAnnotation: BigIntTypeAnnotationBuilder;
+    numberLiteralTypeAnnotation: NumberLiteralTypeAnnotationBuilder;
+    numericLiteralTypeAnnotation: NumericLiteralTypeAnnotationBuilder;
+    bigIntLiteralTypeAnnotation: BigIntLiteralTypeAnnotationBuilder;
+    stringTypeAnnotation: StringTypeAnnotationBuilder;
+    stringLiteralTypeAnnotation: StringLiteralTypeAnnotationBuilder;
+    booleanTypeAnnotation: BooleanTypeAnnotationBuilder;
+    booleanLiteralTypeAnnotation: BooleanLiteralTypeAnnotationBuilder;
+    nullableTypeAnnotation: NullableTypeAnnotationBuilder;
+    nullLiteralTypeAnnotation: NullLiteralTypeAnnotationBuilder;
+    nullTypeAnnotation: NullTypeAnnotationBuilder;
+    thisTypeAnnotation: ThisTypeAnnotationBuilder;
+    existsTypeAnnotation: ExistsTypeAnnotationBuilder;
+    existentialTypeParam: ExistentialTypeParamBuilder;
+    functionTypeAnnotation: FunctionTypeAnnotationBuilder;
+    functionTypeParam: FunctionTypeParamBuilder;
+    arrayTypeAnnotation: ArrayTypeAnnotationBuilder;
+    objectTypeAnnotation: ObjectTypeAnnotationBuilder;
+    objectTypeProperty: ObjectTypePropertyBuilder;
+    objectTypeSpreadProperty: ObjectTypeSpreadPropertyBuilder;
+    objectTypeIndexer: ObjectTypeIndexerBuilder;
+    objectTypeCallProperty: ObjectTypeCallPropertyBuilder;
+    objectTypeInternalSlot: ObjectTypeInternalSlotBuilder;
+    variance: VarianceBuilder;
+    qualifiedTypeIdentifier: QualifiedTypeIdentifierBuilder;
+    genericTypeAnnotation: GenericTypeAnnotationBuilder;
+    memberTypeAnnotation: MemberTypeAnnotationBuilder;
+    indexedAccessType: IndexedAccessTypeBuilder;
+    optionalIndexedAccessType: OptionalIndexedAccessTypeBuilder;
+    unionTypeAnnotation: UnionTypeAnnotationBuilder;
+    intersectionTypeAnnotation: IntersectionTypeAnnotationBuilder;
+    typeofTypeAnnotation: TypeofTypeAnnotationBuilder;
+    typeParameter: TypeParameterBuilder;
+    interfaceTypeAnnotation: InterfaceTypeAnnotationBuilder;
+    interfaceExtends: InterfaceExtendsBuilder;
+    interfaceDeclaration: InterfaceDeclarationBuilder;
+    declareInterface: DeclareInterfaceBuilder;
+    typeAlias: TypeAliasBuilder;
+    declareTypeAlias: DeclareTypeAliasBuilder;
+    opaqueType: OpaqueTypeBuilder;
+    declareOpaqueType: DeclareOpaqueTypeBuilder;
+    typeCastExpression: TypeCastExpressionBuilder;
+    tupleTypeAnnotation: TupleTypeAnnotationBuilder;
+    declareVariable: DeclareVariableBuilder;
+    declareFunction: DeclareFunctionBuilder;
+    declareClass: DeclareClassBuilder;
+    declareModule: DeclareModuleBuilder;
+    declareModuleExports: DeclareModuleExportsBuilder;
+    declareExportDeclaration: DeclareExportDeclarationBuilder;
+    exportBatchSpecifier: ExportBatchSpecifierBuilder;
+    declareExportAllDeclaration: DeclareExportAllDeclarationBuilder;
+    inferredPredicate: InferredPredicateBuilder;
+    declaredPredicate: DeclaredPredicateBuilder;
+    enumDeclaration: EnumDeclarationBuilder;
+    enumBooleanBody: EnumBooleanBodyBuilder;
+    enumNumberBody: EnumNumberBodyBuilder;
+    enumStringBody: EnumStringBodyBuilder;
+    enumSymbolBody: EnumSymbolBodyBuilder;
+    enumBooleanMember: EnumBooleanMemberBuilder;
+    enumNumberMember: EnumNumberMemberBuilder;
+    enumStringMember: EnumStringMemberBuilder;
+    enumDefaultedMember: EnumDefaultedMemberBuilder;
+    exportDeclaration: ExportDeclarationBuilder;
+    block: BlockBuilder;
+    line: LineBuilder;
+    noop: NoopBuilder;
+    doExpression: DoExpressionBuilder;
+    bindExpression: BindExpressionBuilder;
+    parenthesizedExpression: ParenthesizedExpressionBuilder;
+    exportNamespaceSpecifier: ExportNamespaceSpecifierBuilder;
+    exportDefaultSpecifier: ExportDefaultSpecifierBuilder;
+    commentBlock: CommentBlockBuilder;
+    commentLine: CommentLineBuilder;
+    directive: DirectiveBuilder;
+    directiveLiteral: DirectiveLiteralBuilder;
+    interpreterDirective: InterpreterDirectiveBuilder;
+    stringLiteral: StringLiteralBuilder;
+    numericLiteral: NumericLiteralBuilder;
+    bigIntLiteral: BigIntLiteralBuilder;
+    decimalLiteral: DecimalLiteralBuilder;
+    nullLiteral: NullLiteralBuilder;
+    booleanLiteral: BooleanLiteralBuilder;
+    regExpLiteral: RegExpLiteralBuilder;
+    classMethod: ClassMethodBuilder;
+    classPrivateMethod: ClassPrivateMethodBuilder;
+    classAccessorProperty: ClassAccessorPropertyBuilder;
+    restProperty: RestPropertyBuilder;
+    forAwaitStatement: ForAwaitStatementBuilder;
+    import: ImportBuilder;
+    v8IntrinsicIdentifier: V8IntrinsicIdentifierBuilder;
+    topicReference: TopicReferenceBuilder;
+    tsQualifiedName: TSQualifiedNameBuilder;
+    tsTypeReference: TSTypeReferenceBuilder;
+    tsAsExpression: TSAsExpressionBuilder;
+    tsTypeCastExpression: TSTypeCastExpressionBuilder;
+    tsSatisfiesExpression: TSSatisfiesExpressionBuilder;
+    tsNonNullExpression: TSNonNullExpressionBuilder;
+    tsAnyKeyword: TSAnyKeywordBuilder;
+    tsBigIntKeyword: TSBigIntKeywordBuilder;
+    tsBooleanKeyword: TSBooleanKeywordBuilder;
+    tsNeverKeyword: TSNeverKeywordBuilder;
+    tsNullKeyword: TSNullKeywordBuilder;
+    tsNumberKeyword: TSNumberKeywordBuilder;
+    tsObjectKeyword: TSObjectKeywordBuilder;
+    tsStringKeyword: TSStringKeywordBuilder;
+    tsSymbolKeyword: TSSymbolKeywordBuilder;
+    tsUndefinedKeyword: TSUndefinedKeywordBuilder;
+    tsUnknownKeyword: TSUnknownKeywordBuilder;
+    tsVoidKeyword: TSVoidKeywordBuilder;
+    tsIntrinsicKeyword: TSIntrinsicKeywordBuilder;
+    tsThisType: TSThisTypeBuilder;
+    tsArrayType: TSArrayTypeBuilder;
+    tsLiteralType: TSLiteralTypeBuilder;
+    tsUnionType: TSUnionTypeBuilder;
+    tsIntersectionType: TSIntersectionTypeBuilder;
+    tsConditionalType: TSConditionalTypeBuilder;
+    tsInferType: TSInferTypeBuilder;
+    tsTypeParameter: TSTypeParameterBuilder;
+    tsParenthesizedType: TSParenthesizedTypeBuilder;
+    tsFunctionType: TSFunctionTypeBuilder;
+    tsConstructorType: TSConstructorTypeBuilder;
+    tsDeclareFunction: TSDeclareFunctionBuilder;
+    tsDeclareMethod: TSDeclareMethodBuilder;
+    tsMappedType: TSMappedTypeBuilder;
+    tsTupleType: TSTupleTypeBuilder;
+    tsNamedTupleMember: TSNamedTupleMemberBuilder;
+    tsRestType: TSRestTypeBuilder;
+    tsOptionalType: TSOptionalTypeBuilder;
+    tsIndexedAccessType: TSIndexedAccessTypeBuilder;
+    tsTypeOperator: TSTypeOperatorBuilder;
+    tsIndexSignature: TSIndexSignatureBuilder;
+    tsPropertySignature: TSPropertySignatureBuilder;
+    tsMethodSignature: TSMethodSignatureBuilder;
+    tsTypePredicate: TSTypePredicateBuilder;
+    tsCallSignatureDeclaration: TSCallSignatureDeclarationBuilder;
+    tsConstructSignatureDeclaration: TSConstructSignatureDeclarationBuilder;
+    tsEnumMember: TSEnumMemberBuilder;
+    tsTypeQuery: TSTypeQueryBuilder;
+    tsImportType: TSImportTypeBuilder;
+    tsTypeLiteral: TSTypeLiteralBuilder;
+    tsTypeAssertion: TSTypeAssertionBuilder;
+    tsInstantiationExpression: TSInstantiationExpressionBuilder;
+    tsEnumDeclaration: TSEnumDeclarationBuilder;
+    tsTypeAliasDeclaration: TSTypeAliasDeclarationBuilder;
+    tsModuleBlock: TSModuleBlockBuilder;
+    tsModuleDeclaration: TSModuleDeclarationBuilder;
+    tsImportEqualsDeclaration: TSImportEqualsDeclarationBuilder;
+    tsExternalModuleReference: TSExternalModuleReferenceBuilder;
+    tsExportAssignment: TSExportAssignmentBuilder;
+    tsNamespaceExportDeclaration: TSNamespaceExportDeclarationBuilder;
+    tsInterfaceBody: TSInterfaceBodyBuilder;
+    tsInterfaceDeclaration: TSInterfaceDeclarationBuilder;
+    tsParameterProperty: TSParameterPropertyBuilder;
+    [builderName: string]: any;
+}