import { Command } from 'commander';
import { OptionValues } from 'commander';
import postcss from 'postcss';

/** @public */
declare interface AnyTypeAnnotationBuilder {
    (): namedTypes.AnyTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.AnyTypeAnnotation;
}

/** @public */
declare type AnyTypeAnnotationKind = namedTypes.AnyTypeAnnotation;

/** @public */
declare interface ArrayExpressionBuilder {
    (elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | Kinds.RestElementKind | null)[]): namedTypes.ArrayExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | Kinds.RestElementKind | null)[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ArrayExpression;
}

/** @public */
declare type ArrayExpressionKind = namedTypes.ArrayExpression;

/** @public */
declare interface ArrayPatternBuilder {
    (elements: (Kinds.PatternKind | Kinds.SpreadElementKind | null)[]): namedTypes.ArrayPattern;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        elements: (Kinds.PatternKind | Kinds.SpreadElementKind | null)[];
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.ArrayPattern;
}

/** @public */
declare type ArrayPatternKind = namedTypes.ArrayPattern;

declare class ArrayType<T> extends BaseType<T> {
    readonly elemType: Type<T extends (infer E)[] ? E : never>;
    readonly kind: "ArrayType";
    constructor(elemType: Type<T extends (infer E)[] ? E : never>);
    toString(): string;
    check(value: any, deep?: Deep): value is T;
}

/** @public */
declare interface ArrayTypeAnnotationBuilder {
    (elementType: Kinds.FlowTypeKind): namedTypes.ArrayTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elementType: Kinds.FlowTypeKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ArrayTypeAnnotation;
}

/** @public */
declare type ArrayTypeAnnotationKind = namedTypes.ArrayTypeAnnotation;

/** @public */
declare interface ArrowFunctionExpressionBuilder {
    (params: Kinds.PatternKind[], body: Kinds.BlockStatementKind | Kinds.ExpressionKind, expression?: boolean): namedTypes.ArrowFunctionExpression;
    from(params: {
        async?: boolean;
        body: Kinds.BlockStatementKind | Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        defaults?: (Kinds.ExpressionKind | null)[];
        expression?: boolean;
        generator?: false;
        id?: null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ArrowFunctionExpression;
}

/** @public */
declare type ArrowFunctionExpressionKind = namedTypes.ArrowFunctionExpression;

/** @public */
declare interface AssignmentExpressionBuilder {
    (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=", left: Kinds.PatternKind | Kinds.MemberExpressionKind, right: Kinds.ExpressionKind): namedTypes.AssignmentExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.PatternKind | Kinds.MemberExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=";
        right: Kinds.ExpressionKind;
    }): namedTypes.AssignmentExpression;
}

/** @public */
declare type AssignmentExpressionKind = namedTypes.AssignmentExpression;

/** @public */
declare interface AssignmentPatternBuilder {
    (left: Kinds.PatternKind, right: Kinds.ExpressionKind): namedTypes.AssignmentPattern;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        left: Kinds.PatternKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        right: Kinds.ExpressionKind;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.AssignmentPattern;
}

/** @public */
declare type AssignmentPatternKind = namedTypes.AssignmentPattern;

declare namespace AST {
    export {
        HasParent,
        HasLeadingComment,
        NS,
        Namespace,
        Node_2 as Node,
        VForExpression,
        VOnExpression,
        VSlotScopeExpression,
        VFilterSequenceExpression,
        VFilter,
        VGenericExpression,
        VNode,
        TEMPLATE_NODE_TYPES,
        VText,
        HtmlComment,
        VExpressionContainer,
        VIdentifier,
        VDirectiveKey,
        VLiteral,
        VAttribute,
        VDirective,
        VStartTag,
        VEndTag,
        VElement,
        VDocumentFragment,
        VStyleElement,
        traverseNodes
    }
}
export { AST }

export declare namespace astHelpers {
    export {
        findFirst,
        findAll,
        findImportDeclaration,
        createNamedImport,
        createDefaultImport,
        createNamespaceImport,
        findVueComponentOptions
    }
}

declare namespace astHelpers_2 {
    export {
        findFirst,
        findAll,
        findImportDeclaration,
        createNamedImport,
        createDefaultImport,
        createNamespaceImport,
        findVueComponentOptions
    }
}

declare interface ASTNode {
    type: string;
}

/** @public */
declare interface AwaitExpressionBuilder {
    (argument: Kinds.ExpressionKind | null, all?: boolean): namedTypes.AwaitExpression;
    from(params: {
        all?: boolean;
        argument: Kinds.ExpressionKind | null;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.AwaitExpression;
}

/** @public */
declare type AwaitExpressionKind = namedTypes.AwaitExpression;

declare abstract class BaseType<T> {
    abstract toString(): string;
    abstract check(value: any, deep?: Deep): value is T;
    assert(value: any, deep?: Deep): value is T;
    arrayOf(): Type<T[]>;
}

/** @public */
declare interface BigIntLiteralBuilder {
    (value: string | number): namedTypes.BigIntLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        extra?: {
            rawValue: string;
            raw: string;
        };
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: string | number;
    }): namedTypes.BigIntLiteral;
}

/** @public */
declare type BigIntLiteralKind = namedTypes.BigIntLiteral;

/** @public */
declare interface BigIntLiteralTypeAnnotationBuilder {
    (value: null, raw: string): namedTypes.BigIntLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw: string;
        value: null;
    }): namedTypes.BigIntLiteralTypeAnnotation;
}

/** @public */
declare type BigIntLiteralTypeAnnotationKind = namedTypes.BigIntLiteralTypeAnnotation;

/** @public */
declare interface BigIntTypeAnnotationBuilder {
    (): namedTypes.BigIntTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.BigIntTypeAnnotation;
}

/** @public */
declare type BigIntTypeAnnotationKind = namedTypes.BigIntTypeAnnotation;

/** @public */
declare interface BinaryExpressionBuilder {
    (operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "in" | "instanceof" | "**", left: Kinds.ExpressionKind, right: Kinds.ExpressionKind): namedTypes.BinaryExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "in" | "instanceof" | "**";
        right: Kinds.ExpressionKind;
    }): namedTypes.BinaryExpression;
}

/** @public */
declare type BinaryExpressionKind = namedTypes.BinaryExpression;

/** @public */
declare interface BindExpressionBuilder {
    (object: Kinds.ExpressionKind | null, callee: Kinds.ExpressionKind): namedTypes.BindExpression;
    from(params: {
        callee: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.ExpressionKind | null;
    }): namedTypes.BindExpression;
}

/** @public */
declare type BindExpressionKind = namedTypes.BindExpression;

/** @public */
declare interface BlockBuilder {
    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Block;
    from(params: {
        leading?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        trailing?: boolean;
        value: string;
    }): namedTypes.Block;
}

/** @public */
declare type BlockKind = namedTypes.Block;

/** @public */
declare interface BlockStatementBuilder {
    (body: Kinds.StatementKind[]): namedTypes.BlockStatement;
    from(params: {
        body: Kinds.StatementKind[];
        comments?: Kinds.CommentKind[] | null;
        directives?: Kinds.DirectiveKind[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.BlockStatement;
}

/** @public */
declare type BlockStatementKind = namedTypes.BlockStatement;

/** @public */
declare interface BooleanLiteralBuilder {
    (value: boolean): namedTypes.BooleanLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: boolean;
    }): namedTypes.BooleanLiteral;
}

/** @public */
declare type BooleanLiteralKind = namedTypes.BooleanLiteral;

/** @public */
declare interface BooleanLiteralTypeAnnotationBuilder {
    (value: boolean, raw: string): namedTypes.BooleanLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw: string;
        value: boolean;
    }): namedTypes.BooleanLiteralTypeAnnotation;
}

/** @public */
declare type BooleanLiteralTypeAnnotationKind = namedTypes.BooleanLiteralTypeAnnotation;

/** @public */
declare interface BooleanTypeAnnotationBuilder {
    (): namedTypes.BooleanTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.BooleanTypeAnnotation;
}

/** @public */
declare type BooleanTypeAnnotationKind = namedTypes.BooleanTypeAnnotation;

/** @public */
declare interface BreakStatementBuilder {
    (label?: Kinds.IdentifierKind | null): namedTypes.BreakStatement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        label?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.BreakStatement;
}

/** @public */
declare type BreakStatementKind = namedTypes.BreakStatement;

/**
 * @public
 */
export declare type Builders = typeof builders;

/**
 * Combined AST node builders for both script (ESTree/Babel) and template (Vue SFC) nodes.
 *
 * Script builders create JavaScript/TypeScript AST nodes (e.g. `builders.identifier()`,
 * `builders.callExpression()`). Template builders create Vue template AST nodes
 * (e.g. `builders.vElement()`, `builders.vDirective()`).
 *
 * @public
 */
export declare const builders: {
    setParents(node: AST.Node): void;
    vAttribute(key: AST.VAttribute["key"], value: AST.VAttribute["value"]): AST.VAttribute;
    vDirective(key: AST.VDirective["key"], value: AST.VDirective["value"]): AST.VDirective;
    vDirectiveKey(name: AST.VDirectiveKey["name"], argument?: AST.VDirectiveKey["argument"], modifiers?: AST.VDirectiveKey["modifiers"]): AST.VDirectiveKey;
    vDocumentFragment(children: AST.VDocumentFragment["children"]): AST.VDocumentFragment;
    vEndTag(leadingComment?: AST.HtmlComment): AST.VEndTag;
    vElement(name: string, startTag: AST.VStartTag, children: AST.VElement["children"], namespace?: AST.VElement["namespace"]): AST.VElement;
    vExpressionContainer(expression: AST.VExpressionContainer["expression"], leadingComment?: AST.HtmlComment): AST.VExpressionContainer;
    vForExpression(left: AST.VForExpression["left"], right: AST.VForExpression["right"]): AST.VForExpression;
    vIdentifier(name: AST.VIdentifier["name"], rawName?: AST.VIdentifier["rawName"]): AST.VIdentifier;
    vLiteral(value: AST.VLiteral["value"]): AST.VLiteral;
    vStartTag(attributes: AST.VStartTag["attributes"], selfClosing: AST.VStartTag["selfClosing"], leadingComment?: AST.HtmlComment): AST.VStartTag;
    vText(value: AST.VText["value"], leadingComment?: AST.HtmlComment): AST.VText;
    vOnExpression(body: AST.VOnExpression["body"]): AST.VOnExpression;
    vFilterSequenceExpression(expression: AST.VFilterSequenceExpression["expression"], filters: AST.VFilterSequenceExpression["filters"]): AST.VFilterSequenceExpression;
    vFilter(callee: AST.VFilter["callee"], args: AST.VFilter["arguments"]): AST.VFilter;
    htmlComment(value: string, leadingComment?: AST.HtmlComment): AST.HtmlComment;
    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;
    privateIdentifier: PrivateIdentifierBuilder;
    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;
    propertyDefinition: PropertyDefinitionBuilder;
    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;
    tsEnumBody: TSEnumBodyBuilder;
    tsInterfaceHeritage: TSInterfaceHeritageBuilder;
    tsClassImplements: TSClassImplementsBuilder;
    tsTemplateLiteralType: TSTemplateLiteralTypeBuilder;
    tsEmptyBodyFunctionExpression: TSEmptyBodyFunctionExpressionBuilder;
    tsAbstractMethodDefinition: TSAbstractMethodDefinitionBuilder;
    tsAbstractPropertyDefinition: TSAbstractPropertyDefinitionBuilder;
};

/** @public */
declare interface CallExpressionBuilder {
    (callee: Kinds.ExpressionKind, argumentsParam: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[]): namedTypes.CallExpression;
    from(params: {
        arguments: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[];
        callee: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        typeArguments?: null | Kinds.TypeParameterInstantiationKind;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.CallExpression;
}

/** @public */
declare type CallExpressionKind = namedTypes.CallExpression | namedTypes.OptionalCallExpression;

/** @public */
declare interface CatchClauseBuilder {
    (param: Kinds.PatternKind | null | undefined, guard: Kinds.ExpressionKind | null | undefined, body: Kinds.BlockStatementKind): namedTypes.CatchClause;
    from(params: {
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        guard?: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
        param?: Kinds.PatternKind | null;
    }): namedTypes.CatchClause;
}

/** @public */
declare type CatchClauseKind = namedTypes.CatchClause;

/** @public */
declare type ChainElementKind = namedTypes.MemberExpression | namedTypes.CallExpression | namedTypes.OptionalCallExpression | namedTypes.OptionalMemberExpression | namedTypes.JSXMemberExpression;

/** @public */
declare interface ChainExpressionBuilder {
    (expression: Kinds.ChainElementKind): namedTypes.ChainExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ChainElementKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ChainExpression;
}

/** @public */
declare type ChainExpressionKind = namedTypes.ChainExpression;

/** @public */
declare interface ClassAccessorPropertyBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.PrivateNameKind | Kinds.ExpressionKind, value?: Kinds.ExpressionKind | null, decorators?: Kinds.DecoratorKind[] | null, computed?: boolean, staticParam?: boolean): namedTypes.ClassAccessorProperty;
    from(params: {
        abstract?: boolean;
        accessibility?: "public" | "private" | "protected" | null;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.PrivateNameKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
        static?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        value?: Kinds.ExpressionKind | null;
    }): namedTypes.ClassAccessorProperty;
}

/** @public */
declare type ClassAccessorPropertyKind = namedTypes.ClassAccessorProperty;

/** @public */
declare interface ClassBodyBuilder {
    (body: (Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.ClassPrivatePropertyKind | Kinds.ClassMethodKind | Kinds.ClassPrivateMethodKind | Kinds.ClassAccessorPropertyKind | Kinds.StaticBlockKind | Kinds.TSDeclareMethodKind | Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[]): namedTypes.ClassBody;
    from(params: {
        body: (Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.ClassPrivatePropertyKind | Kinds.ClassMethodKind | Kinds.ClassPrivateMethodKind | Kinds.ClassAccessorPropertyKind | Kinds.StaticBlockKind | Kinds.TSDeclareMethodKind | Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ClassBody;
}

/** @public */
declare type ClassBodyKind = namedTypes.ClassBody;

/** @public */
declare interface ClassDeclarationBuilder {
    (id: Kinds.IdentifierKind | null, body: Kinds.ClassBodyKind, superClass?: Kinds.ExpressionKind | null): namedTypes.ClassDeclaration;
    from(params: {
        abstract?: boolean;
        body: Kinds.ClassBodyKind;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        id: Kinds.IdentifierKind | null;
        implements?: Kinds.TSClassImplementsKind[] | Kinds.ClassImplementsKind[] | Kinds.TSExpressionWithTypeArgumentsKind[];
        loc?: Kinds.SourceLocationKind | null;
        superClass?: Kinds.ExpressionKind | null;
        superTypeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
        superTypeParameters?: Kinds.TypeParameterInstantiationKind | Kinds.TSTypeParameterInstantiationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ClassDeclaration;
}

/** @public */
declare type ClassDeclarationKind = namedTypes.ClassDeclaration;

/** @public */
declare interface ClassExpressionBuilder {
    (id: Kinds.IdentifierKind | null | undefined, body: Kinds.ClassBodyKind, superClass?: Kinds.ExpressionKind | null): namedTypes.ClassExpression;
    from(params: {
        abstract?: boolean;
        body: Kinds.ClassBodyKind;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        id?: Kinds.IdentifierKind | null;
        implements?: Kinds.TSClassImplementsKind[] | Kinds.ClassImplementsKind[] | Kinds.TSExpressionWithTypeArgumentsKind[];
        loc?: Kinds.SourceLocationKind | null;
        superClass?: Kinds.ExpressionKind | null;
        superTypeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
        superTypeParameters?: Kinds.TypeParameterInstantiationKind | Kinds.TSTypeParameterInstantiationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ClassExpression;
}

/** @public */
declare type ClassExpressionKind = namedTypes.ClassExpression;

/** @public */
declare interface ClassImplementsBuilder {
    (id: Kinds.IdentifierKind): namedTypes.ClassImplements;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        superClass?: Kinds.ExpressionKind | null;
        typeParameters?: Kinds.TypeParameterInstantiationKind | null;
    }): namedTypes.ClassImplements;
}

/** @public */
declare type ClassImplementsKind = namedTypes.ClassImplements;

/** @public */
declare interface ClassMethodBuilder {
    (kind: "get" | "set" | "method" | "constructor" | undefined, key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, params: Kinds.PatternKind[], body: Kinds.BlockStatementKind, computed?: boolean, staticParam?: boolean): namedTypes.ClassMethod;
    from(params: {
        abstract?: boolean;
        access?: "public" | "private" | "protected" | null;
        accessibility?: "public" | "private" | "protected" | null;
        async?: boolean;
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        defaults?: (Kinds.ExpressionKind | null)[];
        definite?: boolean;
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        kind?: "get" | "set" | "method" | "constructor";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        readonly?: boolean;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        static?: boolean;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ClassMethod;
}

/** @public */
declare type ClassMethodKind = namedTypes.ClassMethod;

/** @public */
declare interface ClassPrivateMethodBuilder {
    (key: Kinds.PrivateNameKind, params: Kinds.PatternKind[], body: Kinds.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: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        defaults?: (Kinds.ExpressionKind | null)[];
        definite?: boolean;
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        key: Kinds.PrivateNameKind;
        kind?: "get" | "set" | "method" | "constructor";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        readonly?: boolean;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        static?: boolean;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ClassPrivateMethod;
}

/** @public */
declare type ClassPrivateMethodKind = namedTypes.ClassPrivateMethod;

/** @public */
declare interface ClassPrivatePropertyBuilder {
    (key: Kinds.PrivateNameKind, value?: Kinds.ExpressionKind | null): namedTypes.ClassPrivateProperty;
    from(params: {
        access?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        key: Kinds.PrivateNameKind;
        loc?: Kinds.SourceLocationKind | null;
        static?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        value?: Kinds.ExpressionKind | null;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.ClassPrivateProperty;
}

/** @public */
declare type ClassPrivatePropertyKind = namedTypes.ClassPrivateProperty;

/** @public */
declare interface ClassPropertyBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, value: Kinds.ExpressionKind | null, typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null, staticParam?: boolean): namedTypes.ClassProperty;
    from(params: {
        access?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        static?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        value: Kinds.ExpressionKind | null;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.ClassProperty;
}

/** @public */
declare interface ClassPropertyDefinitionBuilder {
    (definition: Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.StaticBlockKind): namedTypes.ClassPropertyDefinition;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        definition: Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.StaticBlockKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ClassPropertyDefinition;
}

/** @public */
declare type ClassPropertyDefinitionKind = namedTypes.ClassPropertyDefinition;

/** @public */
declare type ClassPropertyKind = namedTypes.ClassProperty | namedTypes.ClassPrivateProperty | namedTypes.PropertyDefinition | namedTypes.TSAbstractPropertyDefinition;

/**
 * A plugin that updates source code
 * @public
 */
export declare type CodemodPlugin = {
    name: string;
    type: 'codemod';
    /**
     * Mutate the AST to make changes
     * @returns Number of transforms applied. Used for stats
     */
    transform(context: CodemodPluginContext): number;
};

/**
 * @public
 */
export declare type CodemodPluginContext = {
    /**
     * If this is a .vue file, the AST of the `<script>` blocks.
     * If this is a JS/TS module, the 0th element is the AST of the module
     */
    scriptASTs: VueProgram[];
    /**
     * If this is a .vue file, the AST of the SFC. Otherwise, null
     */
    sfcAST: AST.VDocumentFragment | null;
    /**
     * If this is a .vue file, postcss contexts of each \<style\> block
     * If this is a css/scss/less/sass/styl file, the 0th element is the context of the file
     */
    styleASTs: postcss.Root[];
    /**
     * The absolute path of the file being worked on
     */
    filename: string;
    /**
     * Utility functions
     */
    utils: typeof utils;
    /**
     * CLI Options
     */
    opts: Record<string, any>;
};

/** @public */
declare interface CommentBlockBuilder {
    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentBlock;
    from(params: {
        leading?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        trailing?: boolean;
        value: string;
    }): namedTypes.CommentBlock;
}

/** @public */
declare type CommentBlockKind = namedTypes.CommentBlock;

/** @public */
declare type CommentKind = namedTypes.Block | namedTypes.Line | namedTypes.CommentBlock | namedTypes.CommentLine;

/** @public */
declare interface CommentLineBuilder {
    (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentLine;
    from(params: {
        leading?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        trailing?: boolean;
        value: string;
    }): namedTypes.CommentLine;
}

/** @public */
declare type CommentLineKind = namedTypes.CommentLine;

/** @public */
declare interface ComprehensionBlockBuilder {
    (left: Kinds.PatternKind, right: Kinds.ExpressionKind, each: boolean): namedTypes.ComprehensionBlock;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        each: boolean;
        left: Kinds.PatternKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.ExpressionKind;
    }): namedTypes.ComprehensionBlock;
}

/** @public */
declare type ComprehensionBlockKind = namedTypes.ComprehensionBlock;

/** @public */
declare interface ComprehensionExpressionBuilder {
    (body: Kinds.ExpressionKind, blocks: Kinds.ComprehensionBlockKind[], filter: Kinds.ExpressionKind | null): namedTypes.ComprehensionExpression;
    from(params: {
        blocks: Kinds.ComprehensionBlockKind[];
        body: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        filter: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ComprehensionExpression;
}

/** @public */
declare type ComprehensionExpressionKind = namedTypes.ComprehensionExpression;

/** @public */
declare interface ConditionalExpressionBuilder {
    (test: Kinds.ExpressionKind, consequent: Kinds.ExpressionKind, alternate: Kinds.ExpressionKind): namedTypes.ConditionalExpression;
    from(params: {
        alternate: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        consequent: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind;
    }): namedTypes.ConditionalExpression;
}

/** @public */
declare type ConditionalExpressionKind = namedTypes.ConditionalExpression;

declare interface Context extends Omit_2<PathVisitor, "visit" | "reset">, SharedContextMethods {
}

/** @public */
declare interface ContinueStatementBuilder {
    (label?: Kinds.IdentifierKind | null): namedTypes.ContinueStatement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        label?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ContinueStatement;
}

/** @public */
declare type ContinueStatementKind = namedTypes.ContinueStatement;

/**
 * Adds a default import to a script AST. If an import declaration for the module
 * already exists, the default specifier is merged into it. Duplicate imports are skipped.
 *
 * @example
 * ```ts
 * // import Vue from 'vue';
 * createDefaultImport(scriptAST, 'vue', 'Vue');
 * ```
 *
 * @param ast - The script AST
 * @param moduleSpecifier - The module name to import from (e.g. `'vue'`)
 * @param importName - The local name for the default import
 * @public
 */
declare function createDefaultImport(ast: namedTypes.Program, moduleSpecifier: string, importName: string): void;

/**
 * Adds a named import to a script AST. If an import declaration for the module
 * already exists, the new specifier is merged into it. Duplicate imports are skipped.
 *
 * @example
 * ```ts
 * // import { defineComponent } from 'vue';
 * createNamedImport(scriptAST, 'vue', 'defineComponent');
 *
 * // import { map as lodashMap } from 'lodash-es';
 * createNamedImport(scriptAST, 'lodash-es', 'map', 'lodashMap');
 * ```
 *
 * @param ast - The script AST
 * @param moduleSpecifier - The module name to import from (e.g. `'vue'`)
 * @param importName - The exported name of the import
 * @param localName - The local alias (defaults to `importName`)
 * @public
 */
declare function createNamedImport(ast: namedTypes.Program, moduleSpecifier: string, importName: string, localName?: string): void;

/**
 * Adds a namespace (star) import to a script AST. If an import declaration for
 * the module already exists, the namespace specifier is merged into it. Duplicate imports are skipped.
 *
 * @example
 * ```ts
 * // import * as _ from 'lodash-es';
 * createNamespaceImport(scriptAST, 'lodash-es', '_');
 * ```
 *
 * @param ast - The script AST
 * @param moduleSpecifier - The module name to import from (e.g. `'lodash-es'`)
 * @param namespaceName - The local name for the namespace import
 * @public
 */
declare function createNamespaceImport(ast: namedTypes.Program, moduleSpecifier: string, namespaceName: string): void;

/**
 * Creates a CLI runner that globs files and runs codemod/manual-migration plugins against them.
 *
 * Parses `process.argv` for `--files <glob>`, `--plugins <glob...>`, and `--list-plugins` options.
 * Returns an object with `run()`, `abort()`, and `opts()` methods.
 *
 * @example
 * ```ts
 * import { createVueMetamorphCli } from 'vue-metamorph';
 *
 * const { run, abort } = createVueMetamorphCli({
 *   plugins: [myCodemod, myManualMigration],
 *   onProgress({ totalFiles, filesProcessed, stats, done }) {
 *     console.log(`${filesProcessed}/${totalFiles} files processed`);
 *   },
 * });
 *
 * run();
 * ```
 *
 * @public
 */
export declare function createVueMetamorphCli(options: CreateVueMetamorphCliOptions): {
    /**
     * Run the CLI
     */
    run: (argv?: string[]) => Promise<void>;
    /**
     * Stops progress of the runner
     */
    abort: () => void;
    /**
     * Commander arguments
     */
    opts: (argv?: string[]) => OptionValues;
};

/**
 * vue-metamorph CLI Options
 * @public
 */
export declare interface CreateVueMetamorphCliOptions {
    /**
     * Whether to suppress the default output of vue-metamorph's CLI
     *
     * If you set this to true, use the onProgress function to define your own output
     */
    silent?: boolean;
    /**
     * The vue-metamorph CLI will call this function when a file has been transformed
     * and written back to disk
     */
    onProgress?: ProgressCallback;
    /**
     * List of codemods / manual migrations to run against matching files
     */
    plugins: (Plugin_2 | Plugin_2[])[];
    /**
     * Add additional commander options to access with opts()
     * @param program - Commander Command
     */
    additionalCliOptions?: (program: Pick<Command, 'option' | 'requiredOption'>) => void;
}

/** @public */
declare interface DebuggerStatementBuilder {
    (): namedTypes.DebuggerStatement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.DebuggerStatement;
}

/** @public */
declare type DebuggerStatementKind = namedTypes.DebuggerStatement;

/** @public */
declare interface DecimalLiteralBuilder {
    (value: string): namedTypes.DecimalLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        extra?: {
            rawValue: string;
            raw: string;
        };
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: string;
    }): namedTypes.DecimalLiteral;
}

/** @public */
declare type DecimalLiteralKind = namedTypes.DecimalLiteral;

/** @public */
declare type DeclarationKind = namedTypes.VariableDeclaration | namedTypes.FunctionDeclaration | namedTypes.MethodDefinition | namedTypes.ClassPropertyDefinition | namedTypes.ClassProperty | namedTypes.StaticBlock | namedTypes.ClassBody | namedTypes.ClassDeclaration | namedTypes.ImportDeclaration | namedTypes.ExportNamedDeclaration | namedTypes.ExportDefaultDeclaration | namedTypes.ExportAllDeclaration | namedTypes.ClassPrivateProperty | namedTypes.TSTypeParameterDeclaration | namedTypes.PropertyDefinition | namedTypes.InterfaceDeclaration | namedTypes.DeclareInterface | namedTypes.TypeAlias | namedTypes.DeclareTypeAlias | namedTypes.OpaqueType | namedTypes.DeclareOpaqueType | namedTypes.DeclareClass | namedTypes.DeclareExportDeclaration | namedTypes.DeclareExportAllDeclaration | namedTypes.EnumDeclaration | namedTypes.ExportDeclaration | namedTypes.ClassMethod | namedTypes.ClassPrivateMethod | namedTypes.ClassAccessorProperty | namedTypes.TSDeclareFunction | namedTypes.TSDeclareMethod | namedTypes.TSIndexSignature | namedTypes.TSPropertySignature | namedTypes.TSMethodSignature | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration | namedTypes.TSEnumDeclaration | namedTypes.TSTypeAliasDeclaration | namedTypes.TSModuleDeclaration | namedTypes.TSImportEqualsDeclaration | namedTypes.TSExternalModuleReference | namedTypes.TSNamespaceExportDeclaration | namedTypes.TSInterfaceDeclaration | namedTypes.TSAbstractMethodDefinition | namedTypes.TSAbstractPropertyDefinition;

/** @public */
declare interface DeclareClassBuilder {
    (id: Kinds.IdentifierKind): namedTypes.DeclareClass;
    from(params: {
        body: Kinds.ObjectTypeAnnotationKind;
        comments?: Kinds.CommentKind[] | null;
        extends: Kinds.InterfaceExtendsKind[];
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.DeclareClass;
}

/** @public */
declare type DeclareClassKind = namedTypes.DeclareClass;

/** @public */
declare interface DeclaredPredicateBuilder {
    (value: Kinds.ExpressionKind): namedTypes.DeclaredPredicate;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        value: Kinds.ExpressionKind;
    }): namedTypes.DeclaredPredicate;
}

/** @public */
declare type DeclaredPredicateKind = namedTypes.DeclaredPredicate;

/** @public */
declare interface DeclareExportAllDeclarationBuilder {
    (source?: Kinds.LiteralKind | null): namedTypes.DeclareExportAllDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        source?: Kinds.LiteralKind | null;
    }): namedTypes.DeclareExportAllDeclaration;
}

/** @public */
declare type DeclareExportAllDeclarationKind = namedTypes.DeclareExportAllDeclaration;

/** @public */
declare interface DeclareExportDeclarationBuilder {
    (defaultParam: boolean, declaration: Kinds.DeclareVariableKind | Kinds.DeclareFunctionKind | Kinds.DeclareClassKind | Kinds.FlowTypeKind | Kinds.TypeAliasKind | Kinds.DeclareOpaqueTypeKind | Kinds.InterfaceDeclarationKind | null, specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[], source?: Kinds.LiteralKind | null): namedTypes.DeclareExportDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        declaration: Kinds.DeclareVariableKind | Kinds.DeclareFunctionKind | Kinds.DeclareClassKind | Kinds.FlowTypeKind | Kinds.TypeAliasKind | Kinds.DeclareOpaqueTypeKind | Kinds.InterfaceDeclarationKind | null;
        default: boolean;
        loc?: Kinds.SourceLocationKind | null;
        source?: Kinds.LiteralKind | null;
        specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[];
    }): namedTypes.DeclareExportDeclaration;
}

/** @public */
declare type DeclareExportDeclarationKind = namedTypes.DeclareExportDeclaration;

/** @public */
declare interface DeclareFunctionBuilder {
    (id: Kinds.IdentifierKind): namedTypes.DeclareFunction;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        predicate?: Kinds.FlowPredicateKind | null;
    }): namedTypes.DeclareFunction;
}

/** @public */
declare type DeclareFunctionKind = namedTypes.DeclareFunction;

/** @public */
declare interface DeclareInterfaceBuilder {
    (id: Kinds.IdentifierKind, body: Kinds.ObjectTypeAnnotationKind, extendsParam: Kinds.InterfaceExtendsKind[]): namedTypes.DeclareInterface;
    from(params: {
        body: Kinds.ObjectTypeAnnotationKind;
        comments?: Kinds.CommentKind[] | null;
        extends: Kinds.InterfaceExtendsKind[];
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.DeclareInterface;
}

/** @public */
declare type DeclareInterfaceKind = namedTypes.DeclareInterface;

/** @public */
declare interface DeclareModuleBuilder {
    (id: Kinds.IdentifierKind | Kinds.LiteralKind, body: Kinds.BlockStatementKind): namedTypes.DeclareModule;
    from(params: {
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind | Kinds.LiteralKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.DeclareModule;
}

/** @public */
declare interface DeclareModuleExportsBuilder {
    (typeAnnotation: Kinds.TypeAnnotationKind): namedTypes.DeclareModuleExports;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TypeAnnotationKind;
    }): namedTypes.DeclareModuleExports;
}

/** @public */
declare type DeclareModuleExportsKind = namedTypes.DeclareModuleExports;

/** @public */
declare type DeclareModuleKind = namedTypes.DeclareModule;

/** @public */
declare interface DeclareOpaqueTypeBuilder {
    (id: Kinds.IdentifierKind, typeParameters: Kinds.TypeParameterDeclarationKind | null, supertype: Kinds.FlowTypeKind | null): namedTypes.DeclareOpaqueType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        impltype: Kinds.FlowTypeKind | null;
        loc?: Kinds.SourceLocationKind | null;
        supertype: Kinds.FlowTypeKind | null;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.DeclareOpaqueType;
}

/** @public */
declare type DeclareOpaqueTypeKind = namedTypes.DeclareOpaqueType;

/** @public */
declare interface DeclareTypeAliasBuilder {
    (id: Kinds.IdentifierKind, typeParameters: Kinds.TypeParameterDeclarationKind | null, right: Kinds.FlowTypeKind): namedTypes.DeclareTypeAlias;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.FlowTypeKind;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.DeclareTypeAlias;
}

/** @public */
declare type DeclareTypeAliasKind = namedTypes.DeclareTypeAlias;

/** @public */
declare interface DeclareVariableBuilder {
    (id: Kinds.IdentifierKind): namedTypes.DeclareVariable;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.DeclareVariable;
}

/** @public */
declare type DeclareVariableKind = namedTypes.DeclareVariable;

/** @public */
declare interface DecoratorBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.Decorator;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.Decorator;
}

/** @public */
declare type DecoratorKind = namedTypes.Decorator;

declare type Deep = boolean | ((type: Type<any>, value: any) => void);

/** @public */
declare interface DirectiveBuilder {
    (value: Kinds.DirectiveLiteralKind): namedTypes.Directive;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        value: Kinds.DirectiveLiteralKind;
    }): namedTypes.Directive;
}

/** @public */
declare type DirectiveKind = namedTypes.Directive;

/** @public */
declare interface DirectiveLiteralBuilder {
    (value?: string): namedTypes.DirectiveLiteral;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        value?: string;
    }): namedTypes.DirectiveLiteral;
}

/** @public */
declare type DirectiveLiteralKind = namedTypes.DirectiveLiteral;

/** @public */
declare interface DoExpressionBuilder {
    (body: Kinds.StatementKind[]): namedTypes.DoExpression;
    from(params: {
        body: Kinds.StatementKind[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.DoExpression;
}

/** @public */
declare type DoExpressionKind = namedTypes.DoExpression;

/** @public */
declare interface DoWhileStatementBuilder {
    (body: Kinds.StatementKind, test: Kinds.ExpressionKind): namedTypes.DoWhileStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind;
    }): namedTypes.DoWhileStatement;
}

/** @public */
declare type DoWhileStatementKind = namedTypes.DoWhileStatement;

/** @public */
declare interface EmptyStatementBuilder {
    (): namedTypes.EmptyStatement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.EmptyStatement;
}

/** @public */
declare type EmptyStatementKind = namedTypes.EmptyStatement;

/** @public */
declare interface EmptyTypeAnnotationBuilder {
    (): namedTypes.EmptyTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.EmptyTypeAnnotation;
}

/** @public */
declare type EmptyTypeAnnotationKind = namedTypes.EmptyTypeAnnotation;

/** @public */
declare interface EnumBooleanBodyBuilder {
    (members: Kinds.EnumBooleanMemberKind[], explicitType: boolean): namedTypes.EnumBooleanBody;
    from(params: {
        explicitType: boolean;
        members: Kinds.EnumBooleanMemberKind[];
    }): namedTypes.EnumBooleanBody;
}

/** @public */
declare type EnumBooleanBodyKind = namedTypes.EnumBooleanBody;

/** @public */
declare interface EnumBooleanMemberBuilder {
    (id: Kinds.IdentifierKind, init: Kinds.LiteralKind | boolean): namedTypes.EnumBooleanMember;
    from(params: {
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind | boolean;
    }): namedTypes.EnumBooleanMember;
}

/** @public */
declare type EnumBooleanMemberKind = namedTypes.EnumBooleanMember;

/** @public */
declare interface EnumDeclarationBuilder {
    (id: Kinds.IdentifierKind, body: Kinds.EnumBooleanBodyKind | Kinds.EnumNumberBodyKind | Kinds.EnumStringBodyKind | Kinds.EnumSymbolBodyKind): namedTypes.EnumDeclaration;
    from(params: {
        body: Kinds.EnumBooleanBodyKind | Kinds.EnumNumberBodyKind | Kinds.EnumStringBodyKind | Kinds.EnumSymbolBodyKind;
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.EnumDeclaration;
}

/** @public */
declare type EnumDeclarationKind = namedTypes.EnumDeclaration;

/** @public */
declare interface EnumDefaultedMemberBuilder {
    (id: Kinds.IdentifierKind): namedTypes.EnumDefaultedMember;
    from(params: {
        id: Kinds.IdentifierKind;
    }): namedTypes.EnumDefaultedMember;
}

/** @public */
declare type EnumDefaultedMemberKind = namedTypes.EnumDefaultedMember;

/** @public */
declare interface EnumNumberBodyBuilder {
    (members: Kinds.EnumNumberMemberKind[], explicitType: boolean): namedTypes.EnumNumberBody;
    from(params: {
        explicitType: boolean;
        members: Kinds.EnumNumberMemberKind[];
    }): namedTypes.EnumNumberBody;
}

/** @public */
declare type EnumNumberBodyKind = namedTypes.EnumNumberBody;

/** @public */
declare interface EnumNumberMemberBuilder {
    (id: Kinds.IdentifierKind, init: Kinds.LiteralKind): namedTypes.EnumNumberMember;
    from(params: {
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind;
    }): namedTypes.EnumNumberMember;
}

/** @public */
declare type EnumNumberMemberKind = namedTypes.EnumNumberMember;

/** @public */
declare interface EnumStringBodyBuilder {
    (members: Kinds.EnumStringMemberKind[] | Kinds.EnumDefaultedMemberKind[], explicitType: boolean): namedTypes.EnumStringBody;
    from(params: {
        explicitType: boolean;
        members: Kinds.EnumStringMemberKind[] | Kinds.EnumDefaultedMemberKind[];
    }): namedTypes.EnumStringBody;
}

/** @public */
declare type EnumStringBodyKind = namedTypes.EnumStringBody;

/** @public */
declare interface EnumStringMemberBuilder {
    (id: Kinds.IdentifierKind, init: Kinds.LiteralKind): namedTypes.EnumStringMember;
    from(params: {
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind;
    }): namedTypes.EnumStringMember;
}

/** @public */
declare type EnumStringMemberKind = namedTypes.EnumStringMember;

/** @public */
declare interface EnumSymbolBodyBuilder {
    (members: Kinds.EnumDefaultedMemberKind[]): namedTypes.EnumSymbolBody;
    from(params: {
        members: Kinds.EnumDefaultedMemberKind[];
    }): namedTypes.EnumSymbolBody;
}

/** @public */
declare type EnumSymbolBodyKind = namedTypes.EnumSymbolBody;

/**
 * An error that was encountered during parsing or plugin execution
 * @public
 */
export declare type ErrorReport = {
    /**
     * The error object that was thrown
     */
    error: Error;
    /**
     * The filename that was being processed when the error was thrown
     */
    filename: string;
};

/** @public */
declare interface ExistentialTypeParamBuilder {
    (): namedTypes.ExistentialTypeParam;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExistentialTypeParam;
}

/** @public */
declare type ExistentialTypeParamKind = namedTypes.ExistentialTypeParam;

/** @public */
declare interface ExistsTypeAnnotationBuilder {
    (): namedTypes.ExistsTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExistsTypeAnnotation;
}

/** @public */
declare type ExistsTypeAnnotationKind = namedTypes.ExistsTypeAnnotation;

/** @public */
declare interface ExportAllDeclarationBuilder {
    (source: Kinds.LiteralKind, exported?: Kinds.IdentifierKind | null | undefined): namedTypes.ExportAllDeclaration;
    from(params: {
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
        comments?: Kinds.CommentKind[] | null;
        exportKind?: "type" | "value" | undefined;
        exported?: Kinds.IdentifierKind | null | undefined;
        loc?: Kinds.SourceLocationKind | null;
        source: Kinds.LiteralKind;
    }): namedTypes.ExportAllDeclaration;
}

/** @public */
declare type ExportAllDeclarationKind = namedTypes.ExportAllDeclaration;

/** @public */
declare interface ExportBatchSpecifierBuilder {
    (): namedTypes.ExportBatchSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExportBatchSpecifier;
}

/** @public */
declare type ExportBatchSpecifierKind = namedTypes.ExportBatchSpecifier;

/** @public */
declare interface ExportDeclarationBuilder {
    (defaultParam: boolean, declaration: Kinds.DeclarationKind | Kinds.ExpressionKind | null, specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[], source?: Kinds.LiteralKind | null): namedTypes.ExportDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        declaration: Kinds.DeclarationKind | Kinds.ExpressionKind | null;
        default: boolean;
        loc?: Kinds.SourceLocationKind | null;
        source?: Kinds.LiteralKind | null;
        specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[];
    }): namedTypes.ExportDeclaration;
}

/** @public */
declare type ExportDeclarationKind = namedTypes.ExportDeclaration;

/** @public */
declare interface ExportDefaultDeclarationBuilder {
    (declaration: Kinds.DeclarationKind | Kinds.ExpressionKind): namedTypes.ExportDefaultDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        declaration: Kinds.DeclarationKind | Kinds.ExpressionKind;
        exportKind?: "type" | "value" | undefined;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExportDefaultDeclaration;
}

/** @public */
declare type ExportDefaultDeclarationKind = namedTypes.ExportDefaultDeclaration;

/** @public */
declare interface ExportDefaultSpecifierBuilder {
    (exported: Kinds.IdentifierKind): namedTypes.ExportDefaultSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        exported: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExportDefaultSpecifier;
}

/** @public */
declare type ExportDefaultSpecifierKind = namedTypes.ExportDefaultSpecifier;

/** @public */
declare interface ExportNamedDeclarationBuilder {
    (declaration: Kinds.DeclarationKind | null, specifiers?: Kinds.ExportSpecifierKind[], source?: Kinds.LiteralKind | null): namedTypes.ExportNamedDeclaration;
    from(params: {
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
        comments?: Kinds.CommentKind[] | null;
        declaration: Kinds.DeclarationKind | null;
        exportKind?: "type" | "value" | undefined;
        loc?: Kinds.SourceLocationKind | null;
        source?: Kinds.LiteralKind | null;
        specifiers?: Kinds.ExportSpecifierKind[];
    }): namedTypes.ExportNamedDeclaration;
}

/** @public */
declare type ExportNamedDeclarationKind = namedTypes.ExportNamedDeclaration;

/** @public */
declare interface ExportNamespaceSpecifierBuilder {
    (exported: Kinds.IdentifierKind): namedTypes.ExportNamespaceSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        exported: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExportNamespaceSpecifier;
}

/** @public */
declare type ExportNamespaceSpecifierKind = namedTypes.ExportNamespaceSpecifier;

/** @public */
declare interface ExportSpecifierBuilder {
    (id?: Kinds.IdentifierKind | null, name?: Kinds.IdentifierKind | null): namedTypes.ExportSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        exportKind?: "type" | "value" | undefined;
        exported: Kinds.IdentifierKind;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        local?: Kinds.IdentifierKind | null;
        name?: Kinds.IdentifierKind | null;
    }): namedTypes.ExportSpecifier;
}

/** @public */
declare type ExportSpecifierKind = namedTypes.ExportSpecifier;

/** @public */
declare type ExpressionKind = namedTypes.Identifier | namedTypes.FunctionExpression | namedTypes.ThisExpression | namedTypes.ArrayExpression | namedTypes.ObjectExpression | namedTypes.Literal | namedTypes.SequenceExpression | namedTypes.UnaryExpression | namedTypes.BinaryExpression | namedTypes.AssignmentExpression | namedTypes.MemberExpression | namedTypes.UpdateExpression | namedTypes.LogicalExpression | namedTypes.ConditionalExpression | namedTypes.NewExpression | namedTypes.CallExpression | namedTypes.ArrowFunctionExpression | namedTypes.YieldExpression | namedTypes.GeneratorExpression | namedTypes.ComprehensionExpression | namedTypes.ClassExpression | namedTypes.Super | namedTypes.TaggedTemplateExpression | namedTypes.TemplateLiteral | namedTypes.MetaProperty | namedTypes.AwaitExpression | namedTypes.ImportExpression | namedTypes.ChainExpression | namedTypes.OptionalCallExpression | namedTypes.OptionalMemberExpression | namedTypes.PrivateIdentifier | namedTypes.PrivateName | namedTypes.RecordExpression | namedTypes.TupleExpression | namedTypes.JSXIdentifier | namedTypes.JSXExpressionContainer | namedTypes.JSXElement | namedTypes.JSXFragment | namedTypes.JSXMemberExpression | namedTypes.JSXText | namedTypes.TypeCastExpression | namedTypes.DoExpression | namedTypes.BindExpression | namedTypes.ParenthesizedExpression | namedTypes.DirectiveLiteral | namedTypes.StringLiteral | namedTypes.NumericLiteral | namedTypes.BigIntLiteral | namedTypes.DecimalLiteral | namedTypes.NullLiteral | namedTypes.BooleanLiteral | namedTypes.RegExpLiteral | namedTypes.Import | namedTypes.V8IntrinsicIdentifier | namedTypes.TopicReference | namedTypes.TSAsExpression | namedTypes.TSTypeCastExpression | namedTypes.TSSatisfiesExpression | namedTypes.TSNonNullExpression | namedTypes.TSTypeParameter | namedTypes.TSTypeAssertion | namedTypes.TSInstantiationExpression | namedTypes.TSEmptyBodyFunctionExpression;

/** @public */
declare interface ExpressionStatementBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.ExpressionStatement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        directive?: string | undefined;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ExpressionStatement;
}

/** @public */
declare type ExpressionStatementKind = namedTypes.ExpressionStatement;

declare class Field<T> {
    readonly name: string;
    readonly type: Type<T>;
    readonly defaultFn?: Function | undefined;
    readonly hidden: boolean;
    constructor(name: string, type: Type<T>, defaultFn?: Function | undefined, hidden?: boolean);
    toString(): string;
    getValue(obj: {
        [key: string]: any;
    }): any;
}

/** @public */
declare interface FileBuilder {
    (program: Kinds.ProgramKind, name?: string | null): namedTypes.File;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name?: string | null;
        program: Kinds.ProgramKind;
    }): namedTypes.File;
}

/** @public */
declare type FileKind = namedTypes.File;

/**
 * Finds all nodes in an AST that match a partial node using deep partial matching.
 * Works with both script ASTs (ESTree) and template ASTs (vue-eslint-parser).
 *
 * @example
 * ```ts
 * // Find all <MyComponent> elements in the template
 * const els = findAll(sfcAST, { type: 'VElement', name: 'MyComponent' });
 *
 * // Find all v-if directives
 * const vIfs = findAll(sfcAST, {
 *   type: 'VAttribute',
 *   directive: true,
 *   key: { type: 'VDirectiveKey', name: { name: 'if' } },
 * });
 *
 * // Find all call expressions in a script
 * const calls = findAll(scriptAST, { type: 'CallExpression' });
 * ```
 *
 * @param ast - The node to traverse
 * @param matcher - Partial object to match against (uses lodash isMatch)
 * @returns All matching nodes
 * @public
 */
declare function findAll<M extends Matcher<namedTypes.ASTNode | AST.Node>>(ast: AST.Node | namedTypes.ASTNode, matcher: M): (AST.Node & {
    type: M['type'];
})[];

/**
 * Finds the first node in an AST that matches a partial node using deep partial matching.
 * Works with both script ASTs (ESTree) and template ASTs (vue-eslint-parser).
 *
 * @example
 * ```ts
 * // Find the first <div> in the template
 * const div = findFirst(sfcAST, { type: 'VElement', name: 'div' });
 *
 * // Find the first console.log call in a script
 * const log = findFirst(scriptAST, {
 *   type: 'CallExpression',
 *   callee: {
 *     type: 'MemberExpression',
 *     object: { type: 'Identifier', name: 'console' },
 *     property: { type: 'Identifier', name: 'log' },
 *   },
 * });
 * ```
 *
 * @param ast - The node to traverse
 * @param matcher - Partial object to match against (uses lodash isMatch)
 * @returns The first matching node, or null if no matching node was found
 * @public
 */
declare function findFirst<M extends Matcher<namedTypes.ASTNode | AST.Node>>(ast: AST.Node | namedTypes.ASTNode, matcher: M): (AST.Node & {
    type: M['type'];
}) | null;

/**
 * Finds an existing import declaration for a module in a script AST.
 *
 * @example
 * ```ts
 * const vueImport = findImportDeclaration(scriptAST, 'vue');
 * if (vueImport) {
 *   // An `import ... from 'vue'` declaration exists
 * }
 * ```
 *
 * @param ast - The script AST
 * @param moduleSpecifier - The module name (e.g. `'vue'`, `'lodash-es'`)
 * @returns The ImportDeclaration node if one was found, or null
 * @public
 */
declare function findImportDeclaration(ast: namedTypes.Program, moduleSpecifier: string): namedTypes.ImportDeclaration | null;

/**
 * Runs manual migration plugins against source code and returns reports
 * identifying nodes that require human attention. Does not modify the code.
 *
 * @example
 * ```ts
 * import { findManualMigrations, type ManualMigrationPlugin } from 'vue-metamorph';
 *
 * const plugin: ManualMigrationPlugin = {
 *   type: 'manual',
 *   name: 'find-deprecated-api',
 *   find({ scriptASTs, report, utils: { traverseScriptAST } }) {
 *     for (const ast of scriptASTs) {
 *       traverseScriptAST(ast, {
 *         visitCallExpression(path) {
 *           if (path.node.callee.type === 'Identifier'
 *             && path.node.callee.name === 'deprecatedFn') {
 *             report(path.node, 'Replace deprecatedFn with newFn');
 *           }
 *           return this.traverse(path);
 *         },
 *       });
 *     }
 *   },
 * };
 *
 * const reports = findManualMigrations(code, 'file.vue', [plugin]);
 * // Each report: { message, file, snippet, pluginName, lineStart, lineEnd, columnStart, columnEnd }
 * ```
 *
 * @param code - Source code string
 * @param filename - The file name (determines parser selection)
 * @param plugins - Manual migration plugins to run
 * @param opts - Additional options passed through to plugins
 * @returns Array of reports, each identifying a node and message
 * @public
 */
export declare function findManualMigrations(code: string, filename: string, plugins: ManualMigrationPlugin[], opts?: Record<string, any>): ManualMigrationReport[];

/**
 * Finds all Vue Options API object expressions in a script AST.
 *
 * Detects objects passed to `defineComponent()`, `Vue.extend()`, `Vue.component()`,
 * `Vue.mixin()`, and `new Vue()`. When `isSfc` is true, also treats the default export
 * as an options object.
 *
 * @example
 * ```ts
 * for (const scriptAST of scriptASTs) {
 *   const options = findVueComponentOptions(scriptAST, sfcAST !== null);
 *   for (const obj of options) {
 *     // obj is an ObjectExpression — the { ... } passed to defineComponent(), etc.
 *   }
 * }
 * ```
 *
 * @param ast - The script AST
 * @param isSfc - If true, treat the default export as an options api object
 * @returns Array of ObjectExpression nodes
 * @public
 */
declare function findVueComponentOptions(ast: namedTypes.Program, isSfc: boolean): namedTypes.ObjectExpression[];

/** @public */
declare type FlowKind = namedTypes.AnyTypeAnnotation | namedTypes.EmptyTypeAnnotation | namedTypes.MixedTypeAnnotation | namedTypes.VoidTypeAnnotation | namedTypes.SymbolTypeAnnotation | namedTypes.NumberTypeAnnotation | namedTypes.BigIntTypeAnnotation | namedTypes.NumberLiteralTypeAnnotation | namedTypes.NumericLiteralTypeAnnotation | namedTypes.BigIntLiteralTypeAnnotation | namedTypes.StringTypeAnnotation | namedTypes.StringLiteralTypeAnnotation | namedTypes.BooleanTypeAnnotation | namedTypes.BooleanLiteralTypeAnnotation | namedTypes.NullableTypeAnnotation | namedTypes.NullLiteralTypeAnnotation | namedTypes.NullTypeAnnotation | namedTypes.ThisTypeAnnotation | namedTypes.ExistsTypeAnnotation | namedTypes.ExistentialTypeParam | namedTypes.FunctionTypeAnnotation | namedTypes.ArrayTypeAnnotation | namedTypes.ObjectTypeAnnotation | namedTypes.GenericTypeAnnotation | namedTypes.MemberTypeAnnotation | namedTypes.IndexedAccessType | namedTypes.OptionalIndexedAccessType | namedTypes.UnionTypeAnnotation | namedTypes.IntersectionTypeAnnotation | namedTypes.TypeofTypeAnnotation | namedTypes.TypeParameter | namedTypes.InterfaceTypeAnnotation | namedTypes.TupleTypeAnnotation | namedTypes.InferredPredicate | namedTypes.DeclaredPredicate;

/** @public */
declare type FlowPredicateKind = namedTypes.InferredPredicate | namedTypes.DeclaredPredicate;

/** @public */
declare type FlowTypeKind = namedTypes.AnyTypeAnnotation | namedTypes.EmptyTypeAnnotation | namedTypes.MixedTypeAnnotation | namedTypes.VoidTypeAnnotation | namedTypes.SymbolTypeAnnotation | namedTypes.NumberTypeAnnotation | namedTypes.BigIntTypeAnnotation | namedTypes.NumberLiteralTypeAnnotation | namedTypes.NumericLiteralTypeAnnotation | namedTypes.BigIntLiteralTypeAnnotation | namedTypes.StringTypeAnnotation | namedTypes.StringLiteralTypeAnnotation | namedTypes.BooleanTypeAnnotation | namedTypes.BooleanLiteralTypeAnnotation | namedTypes.NullableTypeAnnotation | namedTypes.NullLiteralTypeAnnotation | namedTypes.NullTypeAnnotation | namedTypes.ThisTypeAnnotation | namedTypes.ExistsTypeAnnotation | namedTypes.ExistentialTypeParam | namedTypes.FunctionTypeAnnotation | namedTypes.ArrayTypeAnnotation | namedTypes.ObjectTypeAnnotation | namedTypes.GenericTypeAnnotation | namedTypes.MemberTypeAnnotation | namedTypes.IndexedAccessType | namedTypes.OptionalIndexedAccessType | namedTypes.UnionTypeAnnotation | namedTypes.IntersectionTypeAnnotation | namedTypes.TypeofTypeAnnotation | namedTypes.TypeParameter | namedTypes.InterfaceTypeAnnotation | namedTypes.TupleTypeAnnotation;

/** @public */
declare interface ForAwaitStatementBuilder {
    (left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind, right: Kinds.ExpressionKind, body: Kinds.StatementKind): namedTypes.ForAwaitStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.ExpressionKind;
    }): namedTypes.ForAwaitStatement;
}

/** @public */
declare type ForAwaitStatementKind = namedTypes.ForAwaitStatement;

/** @public */
declare interface ForInStatementBuilder {
    (left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind, right: Kinds.ExpressionKind, body: Kinds.StatementKind): namedTypes.ForInStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.ExpressionKind;
    }): namedTypes.ForInStatement;
}

/** @public */
declare type ForInStatementKind = namedTypes.ForInStatement;

/** @public */
declare interface ForOfStatementBuilder {
    (left: Kinds.VariableDeclarationKind | Kinds.PatternKind, right: Kinds.ExpressionKind, body: Kinds.StatementKind): namedTypes.ForOfStatement;
    from(params: {
        await?: boolean;
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.VariableDeclarationKind | Kinds.PatternKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.ExpressionKind;
    }): namedTypes.ForOfStatement;
}

/** @public */
declare type ForOfStatementKind = namedTypes.ForOfStatement;

/** @public */
declare interface ForStatementBuilder {
    (init: Kinds.VariableDeclarationKind | Kinds.ExpressionKind | null, test: Kinds.ExpressionKind | null, update: Kinds.ExpressionKind | null, body: Kinds.StatementKind): namedTypes.ForStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        init: Kinds.VariableDeclarationKind | Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind | null;
        update: Kinds.ExpressionKind | null;
    }): namedTypes.ForStatement;
}

/** @public */
declare type ForStatementKind = namedTypes.ForStatement;

/** @public */
declare interface FunctionDeclarationBuilder {
    (id: Kinds.IdentifierKind | null, params: Kinds.PatternKind[], body: Kinds.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionDeclaration;
    from(params: {
        async?: boolean;
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        defaults?: (Kinds.ExpressionKind | null)[];
        expression?: boolean;
        generator?: boolean;
        id: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.FunctionDeclaration;
}

/** @public */
declare type FunctionDeclarationKind = namedTypes.FunctionDeclaration;

/** @public */
declare interface FunctionExpressionBuilder {
    (id: Kinds.IdentifierKind | null | undefined, params: Kinds.PatternKind[], body: Kinds.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionExpression;
    from(params: {
        async?: boolean;
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        defaults?: (Kinds.ExpressionKind | null)[];
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.FunctionExpression;
}

/** @public */
declare type FunctionExpressionKind = namedTypes.FunctionExpression | namedTypes.TSEmptyBodyFunctionExpression;

/** @public */
declare type FunctionKind = namedTypes.FunctionDeclaration | namedTypes.FunctionExpression | namedTypes.ArrowFunctionExpression | namedTypes.ObjectMethod | namedTypes.ClassMethod | namedTypes.ClassPrivateMethod | namedTypes.TSEmptyBodyFunctionExpression;

/** @public */
declare interface FunctionTypeAnnotationBuilder {
    (params: Kinds.FunctionTypeParamKind[], returnType: Kinds.FlowTypeKind, rest: Kinds.FunctionTypeParamKind | null, typeParameters: Kinds.TypeParameterDeclarationKind | null): namedTypes.FunctionTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.FunctionTypeParamKind[];
        rest: Kinds.FunctionTypeParamKind | null;
        returnType: Kinds.FlowTypeKind;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.FunctionTypeAnnotation;
}

/** @public */
declare type FunctionTypeAnnotationKind = namedTypes.FunctionTypeAnnotation;

/** @public */
declare interface FunctionTypeParamBuilder {
    (name: Kinds.IdentifierKind | null, typeAnnotation: Kinds.FlowTypeKind, optional: boolean): namedTypes.FunctionTypeParam;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.IdentifierKind | null;
        optional: boolean;
        typeAnnotation: Kinds.FlowTypeKind;
    }): namedTypes.FunctionTypeParam;
}

/** @public */
declare type FunctionTypeParamKind = namedTypes.FunctionTypeParam;

/** @public */
declare interface GeneratorExpressionBuilder {
    (body: Kinds.ExpressionKind, blocks: Kinds.ComprehensionBlockKind[], filter: Kinds.ExpressionKind | null): namedTypes.GeneratorExpression;
    from(params: {
        blocks: Kinds.ComprehensionBlockKind[];
        body: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        filter: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.GeneratorExpression;
}

/** @public */
declare type GeneratorExpressionKind = namedTypes.GeneratorExpression;

/** @public */
declare interface GenericTypeAnnotationBuilder {
    (id: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind, typeParameters: Kinds.TypeParameterInstantiationKind | null): namedTypes.GenericTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters: Kinds.TypeParameterInstantiationKind | null;
    }): namedTypes.GenericTypeAnnotation;
}

/** @public */
declare type GenericTypeAnnotationKind = namedTypes.GenericTypeAnnotation;

/**
 * @public
 */
declare interface HasLeadingComment {
    leadingComment: HtmlComment | null;
}

/**
 * @public
 */
declare interface HasParent {
    parent?: Node_2 | null;
}

/**
 * @public
 */
declare interface HtmlComment extends HasLeadingComment {
    type: 'HtmlComment';
    value: string;
    range: [number, number];
}

/** @public */
declare interface IdentifierBuilder {
    (name: string): namedTypes.Identifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: string;
        optional?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.Identifier;
}

/** @public */
declare type IdentifierKind = namedTypes.Identifier | namedTypes.JSXIdentifier | namedTypes.TSTypeParameter;

declare class IdentityType<T> extends BaseType<T> {
    readonly value: T;
    readonly kind: "IdentityType";
    constructor(value: T);
    toString(): string;
    check(value: any, deep?: Deep): value is T;
}

/** @public */
declare interface IfStatementBuilder {
    (test: Kinds.ExpressionKind, consequent: Kinds.StatementKind, alternate?: Kinds.StatementKind | null): namedTypes.IfStatement;
    from(params: {
        alternate?: Kinds.StatementKind | null;
        comments?: Kinds.CommentKind[] | null;
        consequent: Kinds.StatementKind;
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind;
    }): namedTypes.IfStatement;
}

/** @public */
declare type IfStatementKind = namedTypes.IfStatement;

/** @public */
declare interface ImportAttributeBuilder {
    (key: Kinds.IdentifierKind | Kinds.LiteralKind, value: Kinds.ExpressionKind): namedTypes.ImportAttribute;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        key: Kinds.IdentifierKind | Kinds.LiteralKind;
        loc?: Kinds.SourceLocationKind | null;
        value: Kinds.ExpressionKind;
    }): namedTypes.ImportAttribute;
}

/** @public */
declare type ImportAttributeKind = namedTypes.ImportAttribute;

/** @public */
declare interface ImportBuilder {
    (): namedTypes.Import;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.Import;
}

/** @public */
declare interface ImportDeclarationBuilder {
    (specifiers: (Kinds.ImportSpecifierKind | Kinds.ImportNamespaceSpecifierKind | Kinds.ImportDefaultSpecifierKind)[] | undefined, source: Kinds.LiteralKind, importKind?: "value" | "type" | "typeof"): namedTypes.ImportDeclaration;
    from(params: {
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
        comments?: Kinds.CommentKind[] | null;
        importKind?: "value" | "type" | "typeof";
        loc?: Kinds.SourceLocationKind | null;
        source: Kinds.LiteralKind;
        specifiers?: (Kinds.ImportSpecifierKind | Kinds.ImportNamespaceSpecifierKind | Kinds.ImportDefaultSpecifierKind)[];
    }): namedTypes.ImportDeclaration;
}

/** @public */
declare type ImportDeclarationKind = namedTypes.ImportDeclaration;

/** @public */
declare interface ImportDefaultSpecifierBuilder {
    (local?: Kinds.IdentifierKind | null): namedTypes.ImportDefaultSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        local?: Kinds.IdentifierKind | null;
        name?: Kinds.IdentifierKind | null;
    }): namedTypes.ImportDefaultSpecifier;
}

/** @public */
declare type ImportDefaultSpecifierKind = namedTypes.ImportDefaultSpecifier;

/** @public */
declare interface ImportExpressionBuilder {
    (source: Kinds.ExpressionKind): namedTypes.ImportExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        options?: Kinds.ExpressionKind | null;
        source: Kinds.ExpressionKind;
    }): namedTypes.ImportExpression;
}

/** @public */
declare type ImportExpressionKind = namedTypes.ImportExpression;

/** @public */
declare type ImportKind = namedTypes.Import;

/** @public */
declare interface ImportNamespaceSpecifierBuilder {
    (local?: Kinds.IdentifierKind | null): namedTypes.ImportNamespaceSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        local?: Kinds.IdentifierKind | null;
        name?: Kinds.IdentifierKind | null;
    }): namedTypes.ImportNamespaceSpecifier;
}

/** @public */
declare type ImportNamespaceSpecifierKind = namedTypes.ImportNamespaceSpecifier;

/** @public */
declare interface ImportSpecifierBuilder {
    (imported: Kinds.IdentifierKind, local?: Kinds.IdentifierKind | null): namedTypes.ImportSpecifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id?: Kinds.IdentifierKind | null;
        importKind?: "type" | "typeof" | "value" | null | undefined;
        imported: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        local?: Kinds.IdentifierKind | null;
        name?: Kinds.IdentifierKind | null;
    }): namedTypes.ImportSpecifier;
}

/** @public */
declare type ImportSpecifierKind = namedTypes.ImportSpecifier;

/** @public */
declare interface IndexedAccessTypeBuilder {
    (objectType: Kinds.FlowTypeKind, indexType: Kinds.FlowTypeKind): namedTypes.IndexedAccessType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        indexType: Kinds.FlowTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        objectType: Kinds.FlowTypeKind;
    }): namedTypes.IndexedAccessType;
}

/** @public */
declare type IndexedAccessTypeKind = namedTypes.IndexedAccessType;

/** @public */
declare interface InferredPredicateBuilder {
    (): namedTypes.InferredPredicate;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.InferredPredicate;
}

/** @public */
declare type InferredPredicateKind = namedTypes.InferredPredicate;

/** @public */
declare interface InterfaceDeclarationBuilder {
    (id: Kinds.IdentifierKind, body: Kinds.ObjectTypeAnnotationKind, extendsParam: Kinds.InterfaceExtendsKind[]): namedTypes.InterfaceDeclaration;
    from(params: {
        body: Kinds.ObjectTypeAnnotationKind;
        comments?: Kinds.CommentKind[] | null;
        extends: Kinds.InterfaceExtendsKind[];
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.InterfaceDeclaration;
}

/** @public */
declare type InterfaceDeclarationKind = namedTypes.InterfaceDeclaration | namedTypes.DeclareInterface | namedTypes.DeclareClass;

/** @public */
declare interface InterfaceExtendsBuilder {
    (id: Kinds.IdentifierKind): namedTypes.InterfaceExtends;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TypeParameterInstantiationKind | null;
    }): namedTypes.InterfaceExtends;
}

/** @public */
declare type InterfaceExtendsKind = namedTypes.InterfaceExtends;

/** @public */
declare interface InterfaceTypeAnnotationBuilder {
    (body: Kinds.ObjectTypeAnnotationKind, extendsParam?: Kinds.InterfaceExtendsKind[] | null): namedTypes.InterfaceTypeAnnotation;
    from(params: {
        body: Kinds.ObjectTypeAnnotationKind;
        comments?: Kinds.CommentKind[] | null;
        extends?: Kinds.InterfaceExtendsKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.InterfaceTypeAnnotation;
}

/** @public */
declare type InterfaceTypeAnnotationKind = namedTypes.InterfaceTypeAnnotation;

/** @public */
declare interface InterpreterDirectiveBuilder {
    (value: string): namedTypes.InterpreterDirective;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        value: string;
    }): namedTypes.InterpreterDirective;
}

/** @public */
declare type InterpreterDirectiveKind = namedTypes.InterpreterDirective;

/** @public */
declare interface IntersectionTypeAnnotationBuilder {
    (types: Kinds.FlowTypeKind[]): namedTypes.IntersectionTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        types: Kinds.FlowTypeKind[];
    }): namedTypes.IntersectionTypeAnnotation;
}

/** @public */
declare type IntersectionTypeAnnotationKind = namedTypes.IntersectionTypeAnnotation;

/** @public */
declare interface JSXAttributeBuilder {
    (name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind, value?: Kinds.LiteralKind | Kinds.JSXExpressionContainerKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | null): namedTypes.JSXAttribute;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind;
        value?: Kinds.LiteralKind | Kinds.JSXExpressionContainerKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | null;
    }): namedTypes.JSXAttribute;
}

/** @public */
declare type JSXAttributeKind = namedTypes.JSXAttribute;

/** @public */
declare interface JSXClosingElementBuilder {
    (name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind): namedTypes.JSXClosingElement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
    }): namedTypes.JSXClosingElement;
}

/** @public */
declare type JSXClosingElementKind = namedTypes.JSXClosingElement;

/** @public */
declare interface JSXClosingFragmentBuilder {
    (): namedTypes.JSXClosingFragment;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXClosingFragment;
}

/** @public */
declare type JSXClosingFragmentKind = namedTypes.JSXClosingFragment;

/** @public */
declare interface JSXElementBuilder {
    (openingElement: Kinds.JSXOpeningElementKind, closingElement?: Kinds.JSXClosingElementKind | null, children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[]): namedTypes.JSXElement;
    from(params: {
        attributes?: (Kinds.JSXAttributeKind | Kinds.JSXSpreadAttributeKind)[];
        children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[];
        closingElement?: Kinds.JSXClosingElementKind | null;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name?: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
        openingElement: Kinds.JSXOpeningElementKind;
        selfClosing?: boolean;
    }): namedTypes.JSXElement;
}

/** @public */
declare type JSXElementKind = namedTypes.JSXElement;

/** @public */
declare interface JSXEmptyExpressionBuilder {
    (): namedTypes.JSXEmptyExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXEmptyExpression;
}

/** @public */
declare type JSXEmptyExpressionKind = namedTypes.JSXEmptyExpression;

/** @public */
declare interface JSXExpressionContainerBuilder {
    (expression: Kinds.ExpressionKind | Kinds.JSXEmptyExpressionKind): namedTypes.JSXExpressionContainer;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind | Kinds.JSXEmptyExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXExpressionContainer;
}

/** @public */
declare type JSXExpressionContainerKind = namedTypes.JSXExpressionContainer;

/** @public */
declare interface JSXFragmentBuilder {
    (openingFragment: Kinds.JSXOpeningFragmentKind, closingFragment: Kinds.JSXClosingFragmentKind, children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[]): namedTypes.JSXFragment;
    from(params: {
        children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[];
        closingFragment: Kinds.JSXClosingFragmentKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        openingFragment: Kinds.JSXOpeningFragmentKind;
    }): namedTypes.JSXFragment;
}

/** @public */
declare type JSXFragmentKind = namedTypes.JSXFragment;

/** @public */
declare interface JSXIdentifierBuilder {
    (name: string): namedTypes.JSXIdentifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: string;
        optional?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.JSXIdentifier;
}

/** @public */
declare type JSXIdentifierKind = namedTypes.JSXIdentifier;

/** @public */
declare interface JSXMemberExpressionBuilder {
    (object: Kinds.JSXIdentifierKind | Kinds.JSXMemberExpressionKind, property: Kinds.JSXIdentifierKind): namedTypes.JSXMemberExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.JSXIdentifierKind | Kinds.JSXMemberExpressionKind;
        optional?: boolean;
        property: Kinds.JSXIdentifierKind;
    }): namedTypes.JSXMemberExpression;
}

/** @public */
declare type JSXMemberExpressionKind = namedTypes.JSXMemberExpression;

/** @public */
declare interface JSXNamespacedNameBuilder {
    (namespace: Kinds.JSXIdentifierKind, name: Kinds.JSXIdentifierKind): namedTypes.JSXNamespacedName;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.JSXIdentifierKind;
        namespace: Kinds.JSXIdentifierKind;
    }): namedTypes.JSXNamespacedName;
}

/** @public */
declare type JSXNamespacedNameKind = namedTypes.JSXNamespacedName;

/** @public */
declare interface JSXOpeningElementBuilder {
    (name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind, attributes?: (Kinds.JSXAttributeKind | Kinds.JSXSpreadAttributeKind)[], selfClosing?: boolean): namedTypes.JSXOpeningElement;
    from(params: {
        attributes?: (Kinds.JSXAttributeKind | Kinds.JSXSpreadAttributeKind)[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
        selfClosing?: boolean;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }): namedTypes.JSXOpeningElement;
}

/** @public */
declare type JSXOpeningElementKind = namedTypes.JSXOpeningElement;

/** @public */
declare interface JSXOpeningFragmentBuilder {
    (): namedTypes.JSXOpeningFragment;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXOpeningFragment;
}

/** @public */
declare type JSXOpeningFragmentKind = namedTypes.JSXOpeningFragment;

/** @public */
declare interface JSXSpreadAttributeBuilder {
    (argument: Kinds.ExpressionKind): namedTypes.JSXSpreadAttribute;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXSpreadAttribute;
}

/** @public */
declare type JSXSpreadAttributeKind = namedTypes.JSXSpreadAttribute;

/** @public */
declare interface JSXSpreadChildBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.JSXSpreadChild;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.JSXSpreadChild;
}

/** @public */
declare type JSXSpreadChildKind = namedTypes.JSXSpreadChild;

/** @public */
declare interface JSXTextBuilder {
    (value: string, raw?: string): namedTypes.JSXText;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw?: string;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: string;
    }): namedTypes.JSXText;
}

/** @public */
declare type JSXTextKind = namedTypes.JSXText;

declare namespace Kinds {
    export {
        PrintableKind,
        SourceLocationKind,
        NodeKind,
        CommentKind,
        PositionKind,
        FileKind,
        ProgramKind,
        StatementKind,
        FunctionKind,
        ExpressionKind,
        PatternKind,
        IdentifierKind,
        BlockStatementKind,
        EmptyStatementKind,
        ExpressionStatementKind,
        IfStatementKind,
        LabeledStatementKind,
        BreakStatementKind,
        ContinueStatementKind,
        WithStatementKind,
        SwitchStatementKind,
        SwitchCaseKind,
        ReturnStatementKind,
        ThrowStatementKind,
        TryStatementKind,
        CatchClauseKind,
        WhileStatementKind,
        DoWhileStatementKind,
        ForStatementKind,
        DeclarationKind,
        VariableDeclarationKind,
        ForInStatementKind,
        DebuggerStatementKind,
        FunctionDeclarationKind,
        FunctionExpressionKind,
        VariableDeclaratorKind,
        ThisExpressionKind,
        ArrayExpressionKind,
        ObjectExpressionKind,
        PropertyKind,
        LiteralKind,
        SequenceExpressionKind,
        UnaryExpressionKind,
        BinaryExpressionKind,
        AssignmentExpressionKind,
        ChainElementKind,
        MemberExpressionKind,
        UpdateExpressionKind,
        LogicalExpressionKind,
        ConditionalExpressionKind,
        NewExpressionKind,
        TSHasOptionalTypeParameterInstantiationKind,
        CallExpressionKind,
        RestElementKind,
        TypeAnnotationKind,
        TSTypeAnnotationKind,
        SpreadElementPatternKind,
        ArrowFunctionExpressionKind,
        ForOfStatementKind,
        YieldExpressionKind,
        GeneratorExpressionKind,
        ComprehensionBlockKind,
        ComprehensionExpressionKind,
        ObjectPropertyKind,
        PropertyPatternKind,
        ObjectPatternKind,
        ArrayPatternKind,
        SpreadElementKind,
        AssignmentPatternKind,
        MethodDefinitionKind,
        ClassPropertyDefinitionKind,
        ClassPropertyKind,
        StaticBlockKind,
        ClassBodyKind,
        ClassDeclarationKind,
        ClassExpressionKind,
        SuperKind,
        SpecifierKind,
        ModuleSpecifierKind,
        ImportSpecifierKind,
        ImportDefaultSpecifierKind,
        ImportNamespaceSpecifierKind,
        ImportDeclarationKind,
        ExportNamedDeclarationKind,
        ExportSpecifierKind,
        ExportDefaultDeclarationKind,
        ExportAllDeclarationKind,
        TaggedTemplateExpressionKind,
        TemplateLiteralKind,
        TemplateElementKind,
        MetaPropertyKind,
        AwaitExpressionKind,
        SpreadPropertyKind,
        SpreadPropertyPatternKind,
        ImportExpressionKind,
        ChainExpressionKind,
        OptionalCallExpressionKind,
        OptionalMemberExpressionKind,
        PrivateIdentifierKind,
        DecoratorKind,
        PrivateNameKind,
        ClassPrivatePropertyKind,
        ImportAttributeKind,
        RecordExpressionKind,
        ObjectMethodKind,
        TupleExpressionKind,
        ModuleExpressionKind,
        JSXAttributeKind,
        JSXIdentifierKind,
        JSXNamespacedNameKind,
        JSXExpressionContainerKind,
        JSXElementKind,
        JSXFragmentKind,
        JSXMemberExpressionKind,
        JSXSpreadAttributeKind,
        JSXEmptyExpressionKind,
        JSXTextKind,
        JSXSpreadChildKind,
        JSXOpeningElementKind,
        JSXClosingElementKind,
        JSXOpeningFragmentKind,
        JSXClosingFragmentKind,
        TypeParameterDeclarationKind,
        TSTypeParameterDeclarationKind,
        TypeParameterInstantiationKind,
        TSTypeParameterInstantiationKind,
        ClassImplementsKind,
        TSTypeKind,
        TSExpressionWithTypeArgumentsKind,
        FlowKind,
        FlowTypeKind,
        AnyTypeAnnotationKind,
        EmptyTypeAnnotationKind,
        MixedTypeAnnotationKind,
        VoidTypeAnnotationKind,
        SymbolTypeAnnotationKind,
        NumberTypeAnnotationKind,
        BigIntTypeAnnotationKind,
        NumberLiteralTypeAnnotationKind,
        NumericLiteralTypeAnnotationKind,
        BigIntLiteralTypeAnnotationKind,
        StringTypeAnnotationKind,
        StringLiteralTypeAnnotationKind,
        BooleanTypeAnnotationKind,
        BooleanLiteralTypeAnnotationKind,
        NullableTypeAnnotationKind,
        NullLiteralTypeAnnotationKind,
        NullTypeAnnotationKind,
        ThisTypeAnnotationKind,
        ExistsTypeAnnotationKind,
        ExistentialTypeParamKind,
        FunctionTypeAnnotationKind,
        FunctionTypeParamKind,
        ArrayTypeAnnotationKind,
        ObjectTypeAnnotationKind,
        ObjectTypePropertyKind,
        ObjectTypeSpreadPropertyKind,
        ObjectTypeIndexerKind,
        ObjectTypeCallPropertyKind,
        ObjectTypeInternalSlotKind,
        VarianceKind,
        QualifiedTypeIdentifierKind,
        GenericTypeAnnotationKind,
        MemberTypeAnnotationKind,
        IndexedAccessTypeKind,
        OptionalIndexedAccessTypeKind,
        UnionTypeAnnotationKind,
        IntersectionTypeAnnotationKind,
        TypeofTypeAnnotationKind,
        TypeParameterKind,
        PropertyDefinitionKind,
        InterfaceTypeAnnotationKind,
        InterfaceExtendsKind,
        InterfaceDeclarationKind,
        DeclareInterfaceKind,
        TypeAliasKind,
        DeclareTypeAliasKind,
        OpaqueTypeKind,
        DeclareOpaqueTypeKind,
        TypeCastExpressionKind,
        TupleTypeAnnotationKind,
        DeclareVariableKind,
        DeclareFunctionKind,
        FlowPredicateKind,
        DeclareClassKind,
        DeclareModuleKind,
        DeclareModuleExportsKind,
        DeclareExportDeclarationKind,
        ExportBatchSpecifierKind,
        DeclareExportAllDeclarationKind,
        InferredPredicateKind,
        DeclaredPredicateKind,
        EnumDeclarationKind,
        EnumBooleanBodyKind,
        EnumNumberBodyKind,
        EnumStringBodyKind,
        EnumSymbolBodyKind,
        EnumBooleanMemberKind,
        EnumNumberMemberKind,
        EnumStringMemberKind,
        EnumDefaultedMemberKind,
        ExportDeclarationKind,
        BlockKind,
        LineKind,
        NoopKind,
        DoExpressionKind,
        BindExpressionKind,
        ParenthesizedExpressionKind,
        ExportNamespaceSpecifierKind,
        ExportDefaultSpecifierKind,
        CommentBlockKind,
        CommentLineKind,
        DirectiveKind,
        DirectiveLiteralKind,
        InterpreterDirectiveKind,
        StringLiteralKind,
        NumericLiteralKind,
        BigIntLiteralKind,
        DecimalLiteralKind,
        NullLiteralKind,
        BooleanLiteralKind,
        RegExpLiteralKind,
        ClassMethodKind,
        ClassPrivateMethodKind,
        TSHasOptionalTypeAnnotationKind,
        ClassAccessorPropertyKind,
        RestPropertyKind,
        ForAwaitStatementKind,
        ImportKind,
        V8IntrinsicIdentifierKind,
        TopicReferenceKind,
        TSQualifiedNameKind,
        TSTypeReferenceKind,
        TSHasOptionalTypeParametersKind,
        TSAsExpressionKind,
        TSTypeCastExpressionKind,
        TSSatisfiesExpressionKind,
        TSNonNullExpressionKind,
        TSAnyKeywordKind,
        TSBigIntKeywordKind,
        TSBooleanKeywordKind,
        TSNeverKeywordKind,
        TSNullKeywordKind,
        TSNumberKeywordKind,
        TSObjectKeywordKind,
        TSStringKeywordKind,
        TSSymbolKeywordKind,
        TSUndefinedKeywordKind,
        TSUnknownKeywordKind,
        TSVoidKeywordKind,
        TSIntrinsicKeywordKind,
        TSThisTypeKind,
        TSArrayTypeKind,
        TSLiteralTypeKind,
        TSUnionTypeKind,
        TSIntersectionTypeKind,
        TSConditionalTypeKind,
        TSInferTypeKind,
        TSTypeParameterKind,
        TSParenthesizedTypeKind,
        TSFunctionTypeKind,
        TSConstructorTypeKind,
        TSDeclareFunctionKind,
        TSDeclareMethodKind,
        TSMappedTypeKind,
        TSTupleTypeKind,
        TSNamedTupleMemberKind,
        TSRestTypeKind,
        TSOptionalTypeKind,
        TSIndexedAccessTypeKind,
        TSTypeOperatorKind,
        TSIndexSignatureKind,
        TSPropertySignatureKind,
        TSMethodSignatureKind,
        TSTypePredicateKind,
        TSCallSignatureDeclarationKind,
        TSConstructSignatureDeclarationKind,
        TSEnumMemberKind,
        TSTypeQueryKind,
        TSImportTypeKind,
        TSTypeLiteralKind,
        TSTypeAssertionKind,
        TSInstantiationExpressionKind,
        TSEnumDeclarationKind,
        TSTypeAliasDeclarationKind,
        TSModuleBlockKind,
        TSModuleDeclarationKind,
        TSImportEqualsDeclarationKind,
        TSExternalModuleReferenceKind,
        TSExportAssignmentKind,
        TSNamespaceExportDeclarationKind,
        TSInterfaceBodyKind,
        TSInterfaceDeclarationKind,
        TSParameterPropertyKind,
        TSEnumBodyKind,
        TSInterfaceHeritageKind,
        TSClassImplementsKind,
        TSTemplateLiteralTypeKind,
        TSEmptyBodyFunctionExpressionKind,
        TSAbstractMethodDefinitionKind,
        TSAbstractPropertyDefinitionKind
    }
}
export { Kinds }

/** @public */
declare interface LabeledStatementBuilder {
    (label: Kinds.IdentifierKind, body: Kinds.StatementKind): namedTypes.LabeledStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        label: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.LabeledStatement;
}

/** @public */
declare type LabeledStatementKind = namedTypes.LabeledStatement;

/** @public */
declare interface LineBuilder {
    (value: string, leading?: boolean, trailing?: boolean): namedTypes.Line;
    from(params: {
        leading?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        trailing?: boolean;
        value: string;
    }): namedTypes.Line;
}

/** @public */
declare type LineKind = namedTypes.Line;

/** @public */
declare interface LiteralBuilder {
    (value: string | boolean | null | number | RegExp | BigInt): namedTypes.Literal;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: string | boolean | null | number | RegExp | BigInt;
    }): namedTypes.Literal;
}

/** @public */
declare type LiteralKind = namedTypes.Literal | namedTypes.JSXText | namedTypes.StringLiteral | namedTypes.NumericLiteral | namedTypes.BigIntLiteral | namedTypes.DecimalLiteral | namedTypes.NullLiteral | namedTypes.BooleanLiteral | namedTypes.RegExpLiteral;

/** @public */
declare interface LogicalExpressionBuilder {
    (operator: "||" | "&&" | "??", left: Kinds.ExpressionKind, right: Kinds.ExpressionKind): namedTypes.LogicalExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        operator: "||" | "&&" | "??";
        right: Kinds.ExpressionKind;
    }): namedTypes.LogicalExpression;
}

/** @public */
declare type LogicalExpressionKind = namedTypes.LogicalExpression;

/**
 * A plugin for finding nodes that cannot be migrated automatically
 *
 * @public
 */
export declare type ManualMigrationPlugin = {
    type: 'manual';
    name: string;
    /**
     * Find nodes that need manual migration
     */
    find(context: ManualMigrationPluginContext): void;
};

/**
 * @public
 */
export declare type ManualMigrationPluginContext = {
    /**
     * If this is a .vue file, the AST of the \<script\> blocks.
     * If this is a JS/TS module, the 0th element is the AST of the module
     */
    scriptASTs: VueProgram[];
    /**
     * If this is a .vue file, the AST of the SFC. Otherwise, null
     */
    sfcAST: AST.VDocumentFragment | null;
    /**
     * If this is a .vue file, postcss contexts of each \<style\> block
     * If this is a css/scss/less/sass/styl file, the 0th element is the context of the file
     */
    styleASTs: postcss.Root[];
    /**
     * The absolute path of the file being worked on
     */
    filename: string;
    /**
     * Function to report a node that needs to be migrated
     */
    report: ReportFunction;
    /**
     * Utility functions
     */
    utils: typeof utils;
    /**
     * CLI Options
     */
    opts: Record<string, any>;
};

/**
 * An object containing a manual migration that a ManualMigrationPlugin reported
 * @public
 */
export declare type ManualMigrationReport = {
    /**
     * Migration message
     */
    message: string;
    /**
     * The filename
     */
    file: string;
    /**
     * Code snippet highlighting the node
     */
    snippet: string;
    /**
     * The plugin that generated this report
     */
    pluginName: string;
    /**
     * 1-based index of the starting line number
     */
    lineStart: number;
    /**
     * 1-based index of the ending line number
     */
    lineEnd: number;
    /**
     * 1-based index of the starting column number on the starting line
     */
    columnStart: number;
    /**
     * 1-based index of the enging column number on the ending line
     */
    columnEnd: number;
};

declare type Matcher<T> = T extends {
    type: string;
} ? {
    [key in Exclude<keyof T, 'type' | 'comments' | 'loc' | 'range'>]?: NonNullable<T[key]> extends (infer A)[] ? Matcher<A>[] : Matcher<T[key]>;
} & {
    type: T['type'];
} : T;

/** @public */
declare interface MemberExpressionBuilder {
    (object: Kinds.ExpressionKind, property: Kinds.IdentifierKind | Kinds.ExpressionKind, computed?: boolean): namedTypes.MemberExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.ExpressionKind;
        optional?: boolean;
        property: Kinds.IdentifierKind | Kinds.ExpressionKind;
    }): namedTypes.MemberExpression;
}

/** @public */
declare type MemberExpressionKind = namedTypes.MemberExpression | namedTypes.OptionalMemberExpression | namedTypes.JSXMemberExpression;

/** @public */
declare interface MemberTypeAnnotationBuilder {
    (object: Kinds.IdentifierKind, property: Kinds.MemberTypeAnnotationKind | Kinds.GenericTypeAnnotationKind): namedTypes.MemberTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.IdentifierKind;
        property: Kinds.MemberTypeAnnotationKind | Kinds.GenericTypeAnnotationKind;
    }): namedTypes.MemberTypeAnnotation;
}

/** @public */
declare type MemberTypeAnnotationKind = namedTypes.MemberTypeAnnotation;

/** @public */
declare interface MetaPropertyBuilder {
    (meta: Kinds.IdentifierKind, property: Kinds.IdentifierKind): namedTypes.MetaProperty;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        meta: Kinds.IdentifierKind;
        property: Kinds.IdentifierKind;
    }): namedTypes.MetaProperty;
}

/** @public */
declare type MetaPropertyKind = namedTypes.MetaProperty;

/** @public */
declare interface MethodDefinitionBuilder {
    (kind: "constructor" | "method" | "get" | "set", key: Kinds.ExpressionKind, value: Kinds.FunctionKind, staticParam?: boolean): namedTypes.MethodDefinition;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        key: Kinds.ExpressionKind;
        kind: "constructor" | "method" | "get" | "set";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        static?: boolean;
        value: Kinds.FunctionKind;
    }): namedTypes.MethodDefinition;
}

/** @public */
declare type MethodDefinitionKind = namedTypes.MethodDefinition | namedTypes.TSAbstractMethodDefinition;

/** @public */
declare interface MixedTypeAnnotationBuilder {
    (): namedTypes.MixedTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.MixedTypeAnnotation;
}

/** @public */
declare type MixedTypeAnnotationKind = namedTypes.MixedTypeAnnotation;

/** @public */
declare interface ModuleExpressionBuilder {
    (body: Kinds.ProgramKind): namedTypes.ModuleExpression;
    from(params: {
        body: Kinds.ProgramKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ModuleExpression;
}

/** @public */
declare type ModuleExpressionKind = namedTypes.ModuleExpression;

/** @public */
declare type ModuleSpecifierKind = namedTypes.ImportSpecifier | namedTypes.ImportDefaultSpecifier | namedTypes.ImportNamespaceSpecifier | namedTypes.ExportSpecifier;

/** @public */
export declare namespace namedTypes {
    export interface Printable {
        loc?: Kinds.SourceLocationKind | null;
    }
    export interface SourceLocation {
        start: Kinds.PositionKind;
        end: Kinds.PositionKind;
        source?: string | null;
    }
    export interface Node extends Printable {
        type: string;
        comments?: Kinds.CommentKind[] | null;
    }
    export interface Comment extends Printable {
        value: string;
        leading?: boolean;
        trailing?: boolean;
    }
    export interface Position {
        line: number;
        column: number;
    }
    export interface File extends Omit_2<Node, "type"> {
        type: "File";
        program: Kinds.ProgramKind;
        name?: string | null;
    }
    export interface Program extends Omit_2<Node, "type"> {
        type: "Program";
        body: Kinds.StatementKind[];
        directives?: Kinds.DirectiveKind[];
        interpreter?: Kinds.InterpreterDirectiveKind | null;
        sourceType?: "script" | "module";
    }
    export interface Statement extends Node {
    }
    export interface Function extends Node {
        id?: Kinds.IdentifierKind | null;
        params: Kinds.PatternKind[];
        body: Kinds.BlockStatementKind;
        generator?: boolean;
        async?: boolean;
        expression?: boolean;
        defaults?: (Kinds.ExpressionKind | null)[];
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
        predicate?: Kinds.FlowPredicateKind | null;
    }
    export interface Expression extends Node {
    }
    export interface Pattern extends Node {
    }
    export interface Identifier extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "Identifier";
        name: string;
        optional?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        decorators?: Kinds.DecoratorKind[] | null;
    }
    export interface BlockStatement extends Omit_2<Statement, "type"> {
        type: "BlockStatement";
        body: Kinds.StatementKind[];
        directives?: Kinds.DirectiveKind[];
    }
    export interface EmptyStatement extends Omit_2<Statement, "type"> {
        type: "EmptyStatement";
    }
    export interface ExpressionStatement extends Omit_2<Statement, "type"> {
        type: "ExpressionStatement";
        expression: Kinds.ExpressionKind;
        directive?: string | undefined;
    }
    export interface IfStatement extends Omit_2<Statement, "type"> {
        type: "IfStatement";
        test: Kinds.ExpressionKind;
        consequent: Kinds.StatementKind;
        alternate?: Kinds.StatementKind | null;
    }
    export interface LabeledStatement extends Omit_2<Statement, "type"> {
        type: "LabeledStatement";
        label: Kinds.IdentifierKind;
        body: Kinds.StatementKind;
    }
    export interface BreakStatement extends Omit_2<Statement, "type"> {
        type: "BreakStatement";
        label?: Kinds.IdentifierKind | null;
    }
    export interface ContinueStatement extends Omit_2<Statement, "type"> {
        type: "ContinueStatement";
        label?: Kinds.IdentifierKind | null;
    }
    export interface WithStatement extends Omit_2<Statement, "type"> {
        type: "WithStatement";
        object: Kinds.ExpressionKind;
        body: Kinds.StatementKind;
    }
    export interface SwitchStatement extends Omit_2<Statement, "type"> {
        type: "SwitchStatement";
        discriminant: Kinds.ExpressionKind;
        cases: Kinds.SwitchCaseKind[];
        lexical?: boolean;
    }
    export interface SwitchCase extends Omit_2<Node, "type"> {
        type: "SwitchCase";
        test: Kinds.ExpressionKind | null;
        consequent: Kinds.StatementKind[];
    }
    export interface ReturnStatement extends Omit_2<Statement, "type"> {
        type: "ReturnStatement";
        argument: Kinds.ExpressionKind | null;
    }
    export interface ThrowStatement extends Omit_2<Statement, "type"> {
        type: "ThrowStatement";
        argument: Kinds.ExpressionKind;
    }
    export interface TryStatement extends Omit_2<Statement, "type"> {
        type: "TryStatement";
        block: Kinds.BlockStatementKind;
        handler?: Kinds.CatchClauseKind | null;
        handlers?: Kinds.CatchClauseKind[];
        guardedHandlers?: Kinds.CatchClauseKind[];
        finalizer?: Kinds.BlockStatementKind | null;
    }
    export interface CatchClause extends Omit_2<Node, "type"> {
        type: "CatchClause";
        param?: Kinds.PatternKind | null;
        guard?: Kinds.ExpressionKind | null;
        body: Kinds.BlockStatementKind;
    }
    export interface WhileStatement extends Omit_2<Statement, "type"> {
        type: "WhileStatement";
        test: Kinds.ExpressionKind;
        body: Kinds.StatementKind;
    }
    export interface DoWhileStatement extends Omit_2<Statement, "type"> {
        type: "DoWhileStatement";
        body: Kinds.StatementKind;
        test: Kinds.ExpressionKind;
    }
    export interface ForStatement extends Omit_2<Statement, "type"> {
        type: "ForStatement";
        init: Kinds.VariableDeclarationKind | Kinds.ExpressionKind | null;
        test: Kinds.ExpressionKind | null;
        update: Kinds.ExpressionKind | null;
        body: Kinds.StatementKind;
    }
    export interface Declaration extends Statement {
    }
    export interface VariableDeclaration extends Omit_2<Declaration, "type"> {
        type: "VariableDeclaration";
        kind: "var" | "let" | "const";
        declarations: (Kinds.VariableDeclaratorKind | Kinds.IdentifierKind)[];
        declare?: boolean;
    }
    export interface ForInStatement extends Omit_2<Statement, "type"> {
        type: "ForInStatement";
        left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind;
        right: Kinds.ExpressionKind;
        body: Kinds.StatementKind;
    }
    export interface DebuggerStatement extends Omit_2<Statement, "type"> {
        type: "DebuggerStatement";
    }
    export interface FunctionDeclaration extends Omit_2<Function, "type" | "id">, Omit_2<Declaration, "type"> {
        type: "FunctionDeclaration";
        id: Kinds.IdentifierKind | null;
        declare?: boolean;
    }
    export interface FunctionExpression extends Omit_2<Function, "type">, Omit_2<Expression, "type"> {
        type: "FunctionExpression";
        declare?: boolean;
    }
    export interface VariableDeclarator extends Omit_2<Node, "type"> {
        type: "VariableDeclarator";
        id: Kinds.PatternKind;
        init?: Kinds.ExpressionKind | null;
        definite?: boolean;
    }
    export interface ThisExpression extends Omit_2<Expression, "type"> {
        type: "ThisExpression";
    }
    export interface ArrayExpression extends Omit_2<Expression, "type"> {
        type: "ArrayExpression";
        elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | Kinds.RestElementKind | null)[];
    }
    export interface ObjectExpression extends Omit_2<Expression, "type"> {
        type: "ObjectExpression";
        properties: (Kinds.PropertyKind | Kinds.ObjectMethodKind | Kinds.ObjectPropertyKind | Kinds.SpreadPropertyKind | Kinds.SpreadElementKind)[];
    }
    export interface Property extends Omit_2<Node, "type"> {
        type: "Property";
        kind: "init" | "get" | "set";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        value: Kinds.ExpressionKind | Kinds.PatternKind;
        method?: boolean;
        shorthand?: boolean;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
    }
    export interface Literal extends Omit_2<Expression, "type"> {
        type: "Literal";
        value: string | boolean | null | number | RegExp | BigInt;
        raw?: string | null | undefined;
        bigint?: string | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
    }
    export interface SequenceExpression extends Omit_2<Expression, "type"> {
        type: "SequenceExpression";
        expressions: Kinds.ExpressionKind[];
    }
    export interface UnaryExpression extends Omit_2<Expression, "type"> {
        type: "UnaryExpression";
        operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
        argument: Kinds.ExpressionKind;
        prefix?: boolean;
    }
    export interface BinaryExpression extends Omit_2<Expression, "type"> {
        type: "BinaryExpression";
        operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "in" | "instanceof" | "**";
        left: Kinds.ExpressionKind;
        right: Kinds.ExpressionKind;
    }
    export interface AssignmentExpression extends Omit_2<Expression, "type"> {
        type: "AssignmentExpression";
        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "||=" | "&&=" | "??=";
        left: Kinds.PatternKind | Kinds.MemberExpressionKind;
        right: Kinds.ExpressionKind;
    }
    export interface ChainElement extends Node {
        optional?: boolean;
    }
    export interface MemberExpression extends Omit_2<Expression, "type">, Omit_2<ChainElement, "type"> {
        type: "MemberExpression";
        object: Kinds.ExpressionKind;
        property: Kinds.IdentifierKind | Kinds.ExpressionKind;
        computed?: boolean;
    }
    export interface UpdateExpression extends Omit_2<Expression, "type"> {
        type: "UpdateExpression";
        operator: "++" | "--";
        argument: Kinds.ExpressionKind;
        prefix: boolean;
    }
    export interface LogicalExpression extends Omit_2<Expression, "type"> {
        type: "LogicalExpression";
        operator: "||" | "&&" | "??";
        left: Kinds.ExpressionKind;
        right: Kinds.ExpressionKind;
    }
    export interface ConditionalExpression extends Omit_2<Expression, "type"> {
        type: "ConditionalExpression";
        test: Kinds.ExpressionKind;
        consequent: Kinds.ExpressionKind;
        alternate: Kinds.ExpressionKind;
    }
    export interface NewExpression extends Omit_2<Expression, "type"> {
        type: "NewExpression";
        callee: Kinds.ExpressionKind;
        arguments: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[];
        typeArguments?: null | Kinds.TypeParameterInstantiationKind;
    }
    export interface TSHasOptionalTypeParameterInstantiation {
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }
    export interface CallExpression extends Omit_2<Expression, "type">, Omit_2<ChainElement, "type">, TSHasOptionalTypeParameterInstantiation {
        type: "CallExpression";
        callee: Kinds.ExpressionKind;
        arguments: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[];
        typeArguments?: null | Kinds.TypeParameterInstantiationKind;
    }
    export interface RestElement extends Omit_2<Pattern, "type"> {
        type: "RestElement";
        argument: Kinds.PatternKind;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
        value?: Kinds.ExpressionKind | null;
    }
    export interface TypeAnnotation extends Omit_2<Node, "type"> {
        type: "TypeAnnotation";
        typeAnnotation: Kinds.FlowTypeKind;
    }
    export interface TSTypeAnnotation extends Omit_2<Node, "type"> {
        type: "TSTypeAnnotation";
        typeAnnotation: Kinds.TSTypeKind | Kinds.TSTypeAnnotationKind;
    }
    export interface SpreadElementPattern extends Omit_2<Pattern, "type"> {
        type: "SpreadElementPattern";
        argument: Kinds.PatternKind;
    }
    export interface ArrowFunctionExpression extends Omit_2<Function, "type" | "id" | "body" | "generator">, Omit_2<Expression, "type"> {
        type: "ArrowFunctionExpression";
        id?: null;
        body: Kinds.BlockStatementKind | Kinds.ExpressionKind;
        generator?: false;
    }
    export interface ForOfStatement extends Omit_2<Statement, "type"> {
        type: "ForOfStatement";
        left: Kinds.VariableDeclarationKind | Kinds.PatternKind;
        right: Kinds.ExpressionKind;
        body: Kinds.StatementKind;
        await?: boolean;
    }
    export interface YieldExpression extends Omit_2<Expression, "type"> {
        type: "YieldExpression";
        argument: Kinds.ExpressionKind | null;
        delegate?: boolean;
    }
    export interface GeneratorExpression extends Omit_2<Expression, "type"> {
        type: "GeneratorExpression";
        body: Kinds.ExpressionKind;
        blocks: Kinds.ComprehensionBlockKind[];
        filter: Kinds.ExpressionKind | null;
    }
    export interface ComprehensionBlock extends Omit_2<Node, "type"> {
        type: "ComprehensionBlock";
        left: Kinds.PatternKind;
        right: Kinds.ExpressionKind;
        each: boolean;
    }
    export interface ComprehensionExpression extends Omit_2<Expression, "type"> {
        type: "ComprehensionExpression";
        body: Kinds.ExpressionKind;
        blocks: Kinds.ComprehensionBlockKind[];
        filter: Kinds.ExpressionKind | null;
    }
    export interface ObjectProperty extends Omit_2<Node, "type"> {
        shorthand?: boolean;
        type: "ObjectProperty";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        value: Kinds.ExpressionKind | Kinds.PatternKind;
        accessibility?: Kinds.LiteralKind | null;
        computed?: boolean;
    }
    export interface PropertyPattern extends Omit_2<Pattern, "type"> {
        type: "PropertyPattern";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        pattern: Kinds.PatternKind;
        computed?: boolean;
    }
    export interface ObjectPattern extends Omit_2<Pattern, "type"> {
        type: "ObjectPattern";
        properties: (Kinds.PropertyKind | Kinds.PropertyPatternKind | Kinds.SpreadPropertyPatternKind | Kinds.SpreadPropertyKind | Kinds.ObjectPropertyKind | Kinds.RestPropertyKind | Kinds.RestElementKind)[];
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
    }
    export interface ArrayPattern extends Omit_2<Pattern, "type"> {
        type: "ArrayPattern";
        elements: (Kinds.PatternKind | Kinds.SpreadElementKind | null)[];
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }
    export interface SpreadElement extends Omit_2<Node, "type"> {
        type: "SpreadElement";
        argument: Kinds.ExpressionKind;
    }
    export interface AssignmentPattern extends Omit_2<Pattern, "type"> {
        type: "AssignmentPattern";
        left: Kinds.PatternKind;
        right: Kinds.ExpressionKind;
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }
    export interface MethodDefinition extends Omit_2<Declaration, "type"> {
        type: "MethodDefinition";
        kind: "constructor" | "method" | "get" | "set";
        key: Kinds.ExpressionKind;
        value: Kinds.FunctionKind;
        computed?: boolean;
        static?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        accessibility?: "public" | "private" | "protected" | undefined;
        optional?: boolean;
        override?: boolean;
    }
    export interface ClassPropertyDefinition extends Omit_2<Declaration, "type"> {
        type: "ClassPropertyDefinition";
        definition: Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.StaticBlockKind;
    }
    export interface ClassProperty extends Omit_2<Declaration, "type"> {
        type: "ClassProperty";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        value: Kinds.ExpressionKind | null;
        static?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
        access?: "public" | "private" | "protected" | undefined;
    }
    export interface StaticBlock extends Omit_2<Declaration, "type"> {
        type: "StaticBlock";
        body: Kinds.StatementKind[];
    }
    export interface ClassBody extends Omit_2<Declaration, "type"> {
        type: "ClassBody";
        body: (Kinds.MethodDefinitionKind | Kinds.VariableDeclaratorKind | Kinds.ClassPropertyDefinitionKind | Kinds.ClassPropertyKind | Kinds.ClassPrivatePropertyKind | Kinds.ClassMethodKind | Kinds.ClassPrivateMethodKind | Kinds.ClassAccessorPropertyKind | Kinds.StaticBlockKind | Kinds.TSDeclareMethodKind | Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
    }
    export interface ClassDeclaration extends Omit_2<Declaration, "type"> {
        type: "ClassDeclaration";
        id: Kinds.IdentifierKind | null;
        body: Kinds.ClassBodyKind;
        superClass?: Kinds.ExpressionKind | null;
        decorators?: Kinds.DecoratorKind[] | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
        superTypeParameters?: Kinds.TypeParameterInstantiationKind | Kinds.TSTypeParameterInstantiationKind | null;
        implements?: Kinds.TSClassImplementsKind[] | Kinds.ClassImplementsKind[] | Kinds.TSExpressionWithTypeArgumentsKind[];
        abstract?: boolean;
        declare?: boolean;
        superTypeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface ClassExpression extends Omit_2<Expression, "type"> {
        type: "ClassExpression";
        id?: Kinds.IdentifierKind | null;
        body: Kinds.ClassBodyKind;
        superClass?: Kinds.ExpressionKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
        superTypeParameters?: Kinds.TypeParameterInstantiationKind | Kinds.TSTypeParameterInstantiationKind | null;
        implements?: Kinds.TSClassImplementsKind[] | Kinds.ClassImplementsKind[] | Kinds.TSExpressionWithTypeArgumentsKind[];
        abstract?: boolean;
        declare?: boolean;
        superTypeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface Super extends Omit_2<Expression, "type"> {
        type: "Super";
    }
    export interface Specifier extends Node {
    }
    export interface ModuleSpecifier extends Specifier {
        local?: Kinds.IdentifierKind | null;
        id?: Kinds.IdentifierKind | null;
        name?: Kinds.IdentifierKind | null;
    }
    export interface ImportSpecifier extends Omit_2<ModuleSpecifier, "type"> {
        type: "ImportSpecifier";
        imported: Kinds.IdentifierKind;
        importKind?: "type" | "typeof" | "value" | null | undefined;
    }
    export interface ImportDefaultSpecifier extends Omit_2<ModuleSpecifier, "type"> {
        type: "ImportDefaultSpecifier";
    }
    export interface ImportNamespaceSpecifier extends Omit_2<ModuleSpecifier, "type"> {
        type: "ImportNamespaceSpecifier";
    }
    export interface ImportDeclaration extends Omit_2<Declaration, "type"> {
        type: "ImportDeclaration";
        specifiers?: (Kinds.ImportSpecifierKind | Kinds.ImportNamespaceSpecifierKind | Kinds.ImportDefaultSpecifierKind)[];
        source: Kinds.LiteralKind;
        importKind?: "value" | "type" | "typeof";
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
    }
    export interface ExportNamedDeclaration extends Omit_2<Declaration, "type"> {
        type: "ExportNamedDeclaration";
        declaration: Kinds.DeclarationKind | null;
        specifiers?: Kinds.ExportSpecifierKind[];
        source?: Kinds.LiteralKind | null;
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
        exportKind?: "type" | "value" | undefined;
    }
    export interface ExportSpecifier extends Omit_2<ModuleSpecifier, "type"> {
        type: "ExportSpecifier";
        exported: Kinds.IdentifierKind;
        exportKind?: "type" | "value" | undefined;
    }
    export interface ExportDefaultDeclaration extends Omit_2<Declaration, "type"> {
        type: "ExportDefaultDeclaration";
        declaration: Kinds.DeclarationKind | Kinds.ExpressionKind;
        exportKind?: "type" | "value" | undefined;
    }
    export interface ExportAllDeclaration extends Omit_2<Declaration, "type"> {
        type: "ExportAllDeclaration";
        source: Kinds.LiteralKind;
        exported?: Kinds.IdentifierKind | null | undefined;
        assertions?: Kinds.ImportAttributeKind[];
        attributes?: Kinds.ImportAttributeKind[] | null;
        exportKind?: "type" | "value" | undefined;
    }
    export interface TaggedTemplateExpression extends Omit_2<Expression, "type"> {
        type: "TaggedTemplateExpression";
        tag: Kinds.ExpressionKind;
        quasi: Kinds.TemplateLiteralKind;
    }
    export interface TemplateLiteral extends Omit_2<Expression, "type"> {
        type: "TemplateLiteral";
        quasis: Kinds.TemplateElementKind[];
        expressions: Kinds.ExpressionKind[] | Kinds.TSTypeKind[];
    }
    export interface TemplateElement extends Omit_2<Node, "type"> {
        type: "TemplateElement";
        value: {
            cooked: string | null;
            raw: string;
        };
        tail: boolean;
    }
    export interface MetaProperty extends Omit_2<Expression, "type"> {
        type: "MetaProperty";
        meta: Kinds.IdentifierKind;
        property: Kinds.IdentifierKind;
    }
    export interface AwaitExpression extends Omit_2<Expression, "type"> {
        type: "AwaitExpression";
        argument: Kinds.ExpressionKind | null;
        all?: boolean;
    }
    export interface SpreadProperty extends Omit_2<Node, "type"> {
        type: "SpreadProperty";
        argument: Kinds.ExpressionKind;
    }
    export interface SpreadPropertyPattern extends Omit_2<Pattern, "type"> {
        type: "SpreadPropertyPattern";
        argument: Kinds.PatternKind;
    }
    export interface ImportExpression extends Omit_2<Expression, "type"> {
        type: "ImportExpression";
        source: Kinds.ExpressionKind;
        options?: Kinds.ExpressionKind | null;
    }
    export interface ChainExpression extends Omit_2<Expression, "type"> {
        type: "ChainExpression";
        expression: Kinds.ChainElementKind;
    }
    export interface OptionalCallExpression extends Omit_2<CallExpression, "type" | "optional"> {
        type: "OptionalCallExpression";
        optional?: boolean;
    }
    export interface OptionalMemberExpression extends Omit_2<MemberExpression, "type" | "optional"> {
        type: "OptionalMemberExpression";
        optional?: boolean;
    }
    export interface PrivateIdentifier extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "PrivateIdentifier";
        id: Kinds.IdentifierKind;
        name?: string | undefined;
    }
    export interface Decorator extends Omit_2<Node, "type"> {
        type: "Decorator";
        expression: Kinds.ExpressionKind;
    }
    export interface PrivateName extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "PrivateName";
        id: Kinds.IdentifierKind;
    }
    export interface ClassPrivateProperty extends Omit_2<ClassProperty, "type" | "key" | "value"> {
        type: "ClassPrivateProperty";
        key: Kinds.PrivateNameKind;
        value?: Kinds.ExpressionKind | null;
    }
    export interface ImportAttribute extends Omit_2<Node, "type"> {
        type: "ImportAttribute";
        key: Kinds.IdentifierKind | Kinds.LiteralKind;
        value: Kinds.ExpressionKind;
    }
    export interface RecordExpression extends Omit_2<Expression, "type"> {
        type: "RecordExpression";
        properties: (Kinds.ObjectPropertyKind | Kinds.ObjectMethodKind | Kinds.SpreadElementKind)[];
    }
    export interface ObjectMethod extends Omit_2<Node, "type">, Omit_2<Function, "type" | "params" | "body" | "generator" | "async"> {
        type: "ObjectMethod";
        kind: "method" | "get" | "set";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        params: Kinds.PatternKind[];
        body: Kinds.BlockStatementKind;
        computed?: boolean;
        generator?: boolean;
        async?: boolean;
        accessibility?: Kinds.LiteralKind | null;
        decorators?: Kinds.DecoratorKind[] | null;
    }
    export interface TupleExpression extends Omit_2<Expression, "type"> {
        type: "TupleExpression";
        elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | null)[];
    }
    export interface ModuleExpression extends Omit_2<Node, "type"> {
        type: "ModuleExpression";
        body: Kinds.ProgramKind;
    }
    export interface JSXAttribute extends Omit_2<Node, "type"> {
        type: "JSXAttribute";
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind;
        value?: Kinds.LiteralKind | Kinds.JSXExpressionContainerKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | null;
    }
    export interface JSXIdentifier extends Omit_2<Identifier, "type" | "name"> {
        type: "JSXIdentifier";
        name: string;
    }
    export interface JSXNamespacedName extends Omit_2<Node, "type"> {
        type: "JSXNamespacedName";
        namespace: Kinds.JSXIdentifierKind;
        name: Kinds.JSXIdentifierKind;
    }
    export interface JSXExpressionContainer extends Omit_2<Expression, "type"> {
        type: "JSXExpressionContainer";
        expression: Kinds.ExpressionKind | Kinds.JSXEmptyExpressionKind;
    }
    export interface JSXElement extends Omit_2<Expression, "type"> {
        type: "JSXElement";
        openingElement: Kinds.JSXOpeningElementKind;
        closingElement?: Kinds.JSXClosingElementKind | null;
        children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[];
        name?: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
        selfClosing?: boolean;
        attributes?: (Kinds.JSXAttributeKind | Kinds.JSXSpreadAttributeKind)[];
    }
    export interface JSXFragment extends Omit_2<Expression, "type"> {
        type: "JSXFragment";
        openingFragment: Kinds.JSXOpeningFragmentKind;
        closingFragment: Kinds.JSXClosingFragmentKind;
        children?: (Kinds.JSXTextKind | Kinds.JSXExpressionContainerKind | Kinds.JSXSpreadChildKind | Kinds.JSXElementKind | Kinds.JSXFragmentKind | Kinds.LiteralKind)[];
    }
    export interface JSXMemberExpression extends Omit_2<MemberExpression, "type" | "object" | "property" | "computed"> {
        type: "JSXMemberExpression";
        object: Kinds.JSXIdentifierKind | Kinds.JSXMemberExpressionKind;
        property: Kinds.JSXIdentifierKind;
        computed?: boolean;
    }
    export interface JSXSpreadAttribute extends Omit_2<Node, "type"> {
        type: "JSXSpreadAttribute";
        argument: Kinds.ExpressionKind;
    }
    export interface JSXEmptyExpression extends Omit_2<Node, "type"> {
        type: "JSXEmptyExpression";
    }
    export interface JSXText extends Omit_2<Literal, "type" | "value" | "raw"> {
        type: "JSXText";
        value: string;
        raw?: string;
    }
    export interface JSXSpreadChild extends Omit_2<Node, "type"> {
        type: "JSXSpreadChild";
        expression: Kinds.ExpressionKind;
    }
    export interface JSXOpeningElement extends Omit_2<Node, "type"> {
        type: "JSXOpeningElement";
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
        attributes?: (Kinds.JSXAttributeKind | Kinds.JSXSpreadAttributeKind)[];
        selfClosing?: boolean;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface JSXClosingElement extends Omit_2<Node, "type"> {
        type: "JSXClosingElement";
        name: Kinds.JSXIdentifierKind | Kinds.JSXNamespacedNameKind | Kinds.JSXMemberExpressionKind;
    }
    export interface JSXOpeningFragment extends Omit_2<Node, "type"> {
        type: "JSXOpeningFragment";
    }
    export interface JSXClosingFragment extends Omit_2<Node, "type"> {
        type: "JSXClosingFragment";
    }
    export interface TypeParameterDeclaration extends Omit_2<Node, "type"> {
        type: "TypeParameterDeclaration";
        params: Kinds.TypeParameterKind[];
    }
    export interface TSTypeParameterDeclaration extends Omit_2<Declaration, "type"> {
        type: "TSTypeParameterDeclaration";
        params: Kinds.TSTypeParameterKind[];
    }
    export interface TypeParameterInstantiation extends Omit_2<Node, "type"> {
        type: "TypeParameterInstantiation";
        params: Kinds.FlowTypeKind[];
    }
    export interface TSTypeParameterInstantiation extends Omit_2<Node, "type"> {
        type: "TSTypeParameterInstantiation";
        params: Kinds.TSTypeKind[];
    }
    export interface ClassImplements extends Omit_2<Node, "type"> {
        type: "ClassImplements";
        id: Kinds.IdentifierKind;
        superClass?: Kinds.ExpressionKind | null;
        typeParameters?: Kinds.TypeParameterInstantiationKind | null;
    }
    export interface TSType extends Node {
    }
    export interface TSExpressionWithTypeArguments extends Omit_2<TSType, "type">, TSHasOptionalTypeParameterInstantiation {
        type: "TSExpressionWithTypeArguments";
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
    }
    export interface Flow extends Node {
    }
    export interface FlowType extends Flow {
    }
    export interface AnyTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "AnyTypeAnnotation";
    }
    export interface EmptyTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "EmptyTypeAnnotation";
    }
    export interface MixedTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "MixedTypeAnnotation";
    }
    export interface VoidTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "VoidTypeAnnotation";
    }
    export interface SymbolTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "SymbolTypeAnnotation";
    }
    export interface NumberTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NumberTypeAnnotation";
    }
    export interface BigIntTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "BigIntTypeAnnotation";
    }
    export interface NumberLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NumberLiteralTypeAnnotation";
        value: number;
        raw: string;
    }
    export interface NumericLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NumericLiteralTypeAnnotation";
        value: number;
        raw: string;
    }
    export interface BigIntLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "BigIntLiteralTypeAnnotation";
        value: null;
        raw: string;
    }
    export interface StringTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "StringTypeAnnotation";
    }
    export interface StringLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "StringLiteralTypeAnnotation";
        value: string;
        raw: string;
    }
    export interface BooleanTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "BooleanTypeAnnotation";
    }
    export interface BooleanLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "BooleanLiteralTypeAnnotation";
        value: boolean;
        raw: string;
    }
    export interface NullableTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NullableTypeAnnotation";
        typeAnnotation: Kinds.FlowTypeKind;
    }
    export interface NullLiteralTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NullLiteralTypeAnnotation";
    }
    export interface NullTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "NullTypeAnnotation";
    }
    export interface ThisTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "ThisTypeAnnotation";
    }
    export interface ExistsTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "ExistsTypeAnnotation";
    }
    export interface ExistentialTypeParam extends Omit_2<FlowType, "type"> {
        type: "ExistentialTypeParam";
    }
    export interface FunctionTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "FunctionTypeAnnotation";
        params: Kinds.FunctionTypeParamKind[];
        returnType: Kinds.FlowTypeKind;
        rest: Kinds.FunctionTypeParamKind | null;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }
    export interface FunctionTypeParam extends Omit_2<Node, "type"> {
        type: "FunctionTypeParam";
        name: Kinds.IdentifierKind | null;
        typeAnnotation: Kinds.FlowTypeKind;
        optional: boolean;
    }
    export interface ArrayTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "ArrayTypeAnnotation";
        elementType: Kinds.FlowTypeKind;
    }
    export interface ObjectTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "ObjectTypeAnnotation";
        properties: (Kinds.ObjectTypePropertyKind | Kinds.ObjectTypeSpreadPropertyKind)[];
        indexers?: Kinds.ObjectTypeIndexerKind[];
        callProperties?: Kinds.ObjectTypeCallPropertyKind[];
        inexact?: boolean | undefined;
        exact?: boolean;
        internalSlots?: Kinds.ObjectTypeInternalSlotKind[];
    }
    export interface ObjectTypeProperty extends Omit_2<Node, "type"> {
        type: "ObjectTypeProperty";
        key: Kinds.LiteralKind | Kinds.IdentifierKind;
        value: Kinds.FlowTypeKind;
        optional: boolean;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }
    export interface ObjectTypeSpreadProperty extends Omit_2<Node, "type"> {
        type: "ObjectTypeSpreadProperty";
        argument: Kinds.FlowTypeKind;
    }
    export interface ObjectTypeIndexer extends Omit_2<Node, "type"> {
        type: "ObjectTypeIndexer";
        id: Kinds.IdentifierKind;
        key: Kinds.FlowTypeKind;
        value: Kinds.FlowTypeKind;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
        static?: boolean;
    }
    export interface ObjectTypeCallProperty extends Omit_2<Node, "type"> {
        type: "ObjectTypeCallProperty";
        value: Kinds.FunctionTypeAnnotationKind;
        static?: boolean;
    }
    export interface ObjectTypeInternalSlot extends Omit_2<Node, "type"> {
        type: "ObjectTypeInternalSlot";
        id: Kinds.IdentifierKind;
        value: Kinds.FlowTypeKind;
        optional: boolean;
        static: boolean;
        method: boolean;
    }
    export interface Variance extends Omit_2<Node, "type"> {
        type: "Variance";
        kind: "plus" | "minus";
    }
    export interface QualifiedTypeIdentifier extends Omit_2<Node, "type"> {
        type: "QualifiedTypeIdentifier";
        qualification: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind;
        id: Kinds.IdentifierKind;
    }
    export interface GenericTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "GenericTypeAnnotation";
        id: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind;
        typeParameters: Kinds.TypeParameterInstantiationKind | null;
    }
    export interface MemberTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "MemberTypeAnnotation";
        object: Kinds.IdentifierKind;
        property: Kinds.MemberTypeAnnotationKind | Kinds.GenericTypeAnnotationKind;
    }
    export interface IndexedAccessType extends Omit_2<FlowType, "type"> {
        type: "IndexedAccessType";
        objectType: Kinds.FlowTypeKind;
        indexType: Kinds.FlowTypeKind;
    }
    export interface OptionalIndexedAccessType extends Omit_2<FlowType, "type"> {
        type: "OptionalIndexedAccessType";
        objectType: Kinds.FlowTypeKind;
        indexType: Kinds.FlowTypeKind;
        optional: boolean;
    }
    export interface UnionTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "UnionTypeAnnotation";
        types: Kinds.FlowTypeKind[];
    }
    export interface IntersectionTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "IntersectionTypeAnnotation";
        types: Kinds.FlowTypeKind[];
    }
    export interface TypeofTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "TypeofTypeAnnotation";
        argument: Kinds.FlowTypeKind;
    }
    export interface TypeParameter extends Omit_2<FlowType, "type"> {
        type: "TypeParameter";
        name: string;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
        bound?: Kinds.TypeAnnotationKind | null;
        default?: Kinds.FlowTypeKind | null;
    }
    export interface PropertyDefinition extends Omit_2<ClassProperty, "type"> {
        type: "PropertyDefinition";
        accessibility?: "public" | "private" | "protected" | undefined;
        declare?: boolean;
        definite?: boolean;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
    }
    export interface InterfaceTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "InterfaceTypeAnnotation";
        body: Kinds.ObjectTypeAnnotationKind;
        extends?: Kinds.InterfaceExtendsKind[] | null;
    }
    export interface InterfaceExtends extends Omit_2<Node, "type"> {
        type: "InterfaceExtends";
        id: Kinds.IdentifierKind;
        typeParameters?: Kinds.TypeParameterInstantiationKind | null;
    }
    export interface InterfaceDeclaration extends Omit_2<Declaration, "type"> {
        type: "InterfaceDeclaration";
        id: Kinds.IdentifierKind;
        typeParameters?: Kinds.TypeParameterDeclarationKind | null;
        body: Kinds.ObjectTypeAnnotationKind;
        extends: Kinds.InterfaceExtendsKind[];
    }
    export interface DeclareInterface extends Omit_2<InterfaceDeclaration, "type"> {
        type: "DeclareInterface";
    }
    export interface TypeAlias extends Omit_2<Declaration, "type"> {
        type: "TypeAlias";
        id: Kinds.IdentifierKind;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
        right: Kinds.FlowTypeKind;
    }
    export interface DeclareTypeAlias extends Omit_2<TypeAlias, "type"> {
        type: "DeclareTypeAlias";
    }
    export interface OpaqueType extends Omit_2<Declaration, "type"> {
        type: "OpaqueType";
        id: Kinds.IdentifierKind;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
        impltype: Kinds.FlowTypeKind;
        supertype: Kinds.FlowTypeKind | null;
    }
    export interface DeclareOpaqueType extends Omit_2<OpaqueType, "type" | "impltype"> {
        type: "DeclareOpaqueType";
        impltype: Kinds.FlowTypeKind | null;
    }
    export interface TypeCastExpression extends Omit_2<Expression, "type"> {
        type: "TypeCastExpression";
        expression: Kinds.ExpressionKind;
        typeAnnotation: Kinds.TypeAnnotationKind;
    }
    export interface TupleTypeAnnotation extends Omit_2<FlowType, "type"> {
        type: "TupleTypeAnnotation";
        types: Kinds.FlowTypeKind[];
    }
    export interface DeclareVariable extends Omit_2<Statement, "type"> {
        type: "DeclareVariable";
        id: Kinds.IdentifierKind;
    }
    export interface DeclareFunction extends Omit_2<Statement, "type"> {
        type: "DeclareFunction";
        id: Kinds.IdentifierKind;
        predicate?: Kinds.FlowPredicateKind | null;
    }
    export interface FlowPredicate extends Flow {
    }
    export interface DeclareClass extends Omit_2<InterfaceDeclaration, "type"> {
        type: "DeclareClass";
    }
    export interface DeclareModule extends Omit_2<Statement, "type"> {
        type: "DeclareModule";
        id: Kinds.IdentifierKind | Kinds.LiteralKind;
        body: Kinds.BlockStatementKind;
    }
    export interface DeclareModuleExports extends Omit_2<Statement, "type"> {
        type: "DeclareModuleExports";
        typeAnnotation: Kinds.TypeAnnotationKind;
    }
    export interface DeclareExportDeclaration extends Omit_2<Declaration, "type"> {
        type: "DeclareExportDeclaration";
        default: boolean;
        declaration: Kinds.DeclareVariableKind | Kinds.DeclareFunctionKind | Kinds.DeclareClassKind | Kinds.FlowTypeKind | Kinds.TypeAliasKind | Kinds.DeclareOpaqueTypeKind | Kinds.InterfaceDeclarationKind | null;
        specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[];
        source?: Kinds.LiteralKind | null;
    }
    export interface ExportBatchSpecifier extends Omit_2<Specifier, "type"> {
        type: "ExportBatchSpecifier";
    }
    export interface DeclareExportAllDeclaration extends Omit_2<Declaration, "type"> {
        type: "DeclareExportAllDeclaration";
        source?: Kinds.LiteralKind | null;
    }
    export interface InferredPredicate extends Omit_2<FlowPredicate, "type"> {
        type: "InferredPredicate";
    }
    export interface DeclaredPredicate extends Omit_2<FlowPredicate, "type"> {
        type: "DeclaredPredicate";
        value: Kinds.ExpressionKind;
    }
    export interface EnumDeclaration extends Omit_2<Declaration, "type"> {
        type: "EnumDeclaration";
        id: Kinds.IdentifierKind;
        body: Kinds.EnumBooleanBodyKind | Kinds.EnumNumberBodyKind | Kinds.EnumStringBodyKind | Kinds.EnumSymbolBodyKind;
    }
    export interface EnumBooleanBody {
        type: "EnumBooleanBody";
        members: Kinds.EnumBooleanMemberKind[];
        explicitType: boolean;
    }
    export interface EnumNumberBody {
        type: "EnumNumberBody";
        members: Kinds.EnumNumberMemberKind[];
        explicitType: boolean;
    }
    export interface EnumStringBody {
        type: "EnumStringBody";
        members: Kinds.EnumStringMemberKind[] | Kinds.EnumDefaultedMemberKind[];
        explicitType: boolean;
    }
    export interface EnumSymbolBody {
        type: "EnumSymbolBody";
        members: Kinds.EnumDefaultedMemberKind[];
    }
    export interface EnumBooleanMember {
        type: "EnumBooleanMember";
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind | boolean;
    }
    export interface EnumNumberMember {
        type: "EnumNumberMember";
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind;
    }
    export interface EnumStringMember {
        type: "EnumStringMember";
        id: Kinds.IdentifierKind;
        init: Kinds.LiteralKind;
    }
    export interface EnumDefaultedMember {
        type: "EnumDefaultedMember";
        id: Kinds.IdentifierKind;
    }
    export interface ExportDeclaration extends Omit_2<Declaration, "type"> {
        type: "ExportDeclaration";
        default: boolean;
        declaration: Kinds.DeclarationKind | Kinds.ExpressionKind | null;
        specifiers?: (Kinds.ExportSpecifierKind | Kinds.ExportBatchSpecifierKind)[];
        source?: Kinds.LiteralKind | null;
    }
    export interface Block extends Comment {
        type: "Block";
    }
    export interface Line extends Comment {
        type: "Line";
    }
    export interface Noop extends Omit_2<Statement, "type"> {
        type: "Noop";
    }
    export interface DoExpression extends Omit_2<Expression, "type"> {
        type: "DoExpression";
        body: Kinds.StatementKind[];
    }
    export interface BindExpression extends Omit_2<Expression, "type"> {
        type: "BindExpression";
        object: Kinds.ExpressionKind | null;
        callee: Kinds.ExpressionKind;
    }
    export interface ParenthesizedExpression extends Omit_2<Expression, "type"> {
        type: "ParenthesizedExpression";
        expression: Kinds.ExpressionKind;
    }
    export interface ExportNamespaceSpecifier extends Omit_2<Specifier, "type"> {
        type: "ExportNamespaceSpecifier";
        exported: Kinds.IdentifierKind;
    }
    export interface ExportDefaultSpecifier extends Omit_2<Specifier, "type"> {
        type: "ExportDefaultSpecifier";
        exported: Kinds.IdentifierKind;
    }
    export interface CommentBlock extends Comment {
        type: "CommentBlock";
    }
    export interface CommentLine extends Comment {
        type: "CommentLine";
    }
    export interface Directive extends Omit_2<Node, "type"> {
        type: "Directive";
        value: Kinds.DirectiveLiteralKind;
    }
    export interface DirectiveLiteral extends Omit_2<Node, "type">, Omit_2<Expression, "type"> {
        type: "DirectiveLiteral";
        value?: string;
    }
    export interface InterpreterDirective extends Omit_2<Node, "type"> {
        type: "InterpreterDirective";
        value: string;
    }
    export interface StringLiteral extends Omit_2<Literal, "type" | "value"> {
        type: "StringLiteral";
        value: string;
        extra?: {
            rawValue: string;
            raw: string;
        };
    }
    export interface NumericLiteral extends Omit_2<Literal, "type" | "value" | "raw"> {
        type: "NumericLiteral";
        value: number;
        raw?: string | null;
        extra?: {
            rawValue: number;
            raw: string;
        };
    }
    export interface BigIntLiteral extends Omit_2<Literal, "type" | "value"> {
        type: "BigIntLiteral";
        value: string | number;
        extra?: {
            rawValue: string;
            raw: string;
        };
    }
    export interface DecimalLiteral extends Omit_2<Literal, "type" | "value"> {
        type: "DecimalLiteral";
        value: string;
        extra?: {
            rawValue: string;
            raw: string;
        };
    }
    export interface NullLiteral extends Omit_2<Literal, "type" | "value"> {
        type: "NullLiteral";
        value?: null;
    }
    export interface BooleanLiteral extends Omit_2<Literal, "type" | "value"> {
        type: "BooleanLiteral";
        value: boolean;
    }
    export interface RegExpLiteral extends Omit_2<Literal, "type" | "value" | "regex"> {
        type: "RegExpLiteral";
        pattern: string;
        flags: string;
        value?: RegExp;
        extra?: {
            rawValue: RegExp | undefined;
            raw: string;
        };
        regex?: {
            pattern: string;
            flags: string;
        };
    }
    export interface ClassMethod extends Omit_2<Declaration, "type">, Omit_2<Function, "type" | "body"> {
        type: "ClassMethod";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        kind?: "get" | "set" | "method" | "constructor";
        body: Kinds.BlockStatementKind;
        access?: "public" | "private" | "protected" | null;
        computed?: boolean;
        static?: boolean;
        abstract?: boolean;
        accessibility?: "public" | "private" | "protected" | null;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
    }
    export interface ClassPrivateMethod extends Omit_2<Declaration, "type">, Omit_2<Function, "type" | "body"> {
        type: "ClassPrivateMethod";
        key: Kinds.PrivateNameKind;
        kind?: "get" | "set" | "method" | "constructor";
        body: Kinds.BlockStatementKind;
        access?: "public" | "private" | "protected" | null;
        computed?: boolean;
        static?: boolean;
        abstract?: boolean;
        accessibility?: "public" | "private" | "protected" | null;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
    }
    export interface TSHasOptionalTypeAnnotation {
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }
    export interface ClassAccessorProperty extends Omit_2<Declaration, "type">, TSHasOptionalTypeAnnotation {
        type: "ClassAccessorProperty";
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.PrivateNameKind | Kinds.ExpressionKind;
        value?: Kinds.ExpressionKind | null;
        computed?: boolean;
        static?: boolean;
        abstract?: boolean;
        accessibility?: "public" | "private" | "protected" | null;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
    }
    export interface RestProperty extends Omit_2<Node, "type"> {
        type: "RestProperty";
        argument: Kinds.ExpressionKind;
    }
    export interface ForAwaitStatement extends Omit_2<Statement, "type"> {
        type: "ForAwaitStatement";
        left: Kinds.VariableDeclarationKind | Kinds.ExpressionKind;
        right: Kinds.ExpressionKind;
        body: Kinds.StatementKind;
    }
    export interface Import extends Omit_2<Expression, "type"> {
        type: "Import";
    }
    export interface V8IntrinsicIdentifier extends Omit_2<Expression, "type"> {
        type: "V8IntrinsicIdentifier";
        name: string;
    }
    export interface TopicReference extends Omit_2<Expression, "type"> {
        type: "TopicReference";
    }
    export interface TSQualifiedName extends Omit_2<Node, "type"> {
        type: "TSQualifiedName";
        left: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        right: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
    }
    export interface TSTypeReference extends Omit_2<TSType, "type">, TSHasOptionalTypeParameterInstantiation {
        type: "TSTypeReference";
        typeName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface TSHasOptionalTypeParameters {
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }
    export interface TSAsExpression extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "TSAsExpression";
        expression: Kinds.ExpressionKind;
        typeAnnotation: Kinds.TSTypeKind;
        extra?: {
            parenthesized: boolean;
        } | null;
    }
    export interface TSTypeCastExpression extends Omit_2<Expression, "type"> {
        type: "TSTypeCastExpression";
        expression: Kinds.ExpressionKind;
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSSatisfiesExpression extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "TSSatisfiesExpression";
        expression: Kinds.ExpressionKind;
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSNonNullExpression extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "TSNonNullExpression";
        expression: Kinds.ExpressionKind;
    }
    export interface TSAnyKeyword extends Omit_2<TSType, "type"> {
        type: "TSAnyKeyword";
    }
    export interface TSBigIntKeyword extends Omit_2<TSType, "type"> {
        type: "TSBigIntKeyword";
    }
    export interface TSBooleanKeyword extends Omit_2<TSType, "type"> {
        type: "TSBooleanKeyword";
    }
    export interface TSNeverKeyword extends Omit_2<TSType, "type"> {
        type: "TSNeverKeyword";
    }
    export interface TSNullKeyword extends Omit_2<TSType, "type"> {
        type: "TSNullKeyword";
    }
    export interface TSNumberKeyword extends Omit_2<TSType, "type"> {
        type: "TSNumberKeyword";
    }
    export interface TSObjectKeyword extends Omit_2<TSType, "type"> {
        type: "TSObjectKeyword";
    }
    export interface TSStringKeyword extends Omit_2<TSType, "type"> {
        type: "TSStringKeyword";
    }
    export interface TSSymbolKeyword extends Omit_2<TSType, "type"> {
        type: "TSSymbolKeyword";
    }
    export interface TSUndefinedKeyword extends Omit_2<TSType, "type"> {
        type: "TSUndefinedKeyword";
    }
    export interface TSUnknownKeyword extends Omit_2<TSType, "type"> {
        type: "TSUnknownKeyword";
    }
    export interface TSVoidKeyword extends Omit_2<TSType, "type"> {
        type: "TSVoidKeyword";
    }
    export interface TSIntrinsicKeyword extends Omit_2<TSType, "type"> {
        type: "TSIntrinsicKeyword";
    }
    export interface TSThisType extends Omit_2<TSType, "type"> {
        type: "TSThisType";
    }
    export interface TSArrayType extends Omit_2<TSType, "type"> {
        type: "TSArrayType";
        elementType: Kinds.TSTypeKind;
    }
    export interface TSLiteralType extends Omit_2<TSType, "type"> {
        type: "TSLiteralType";
        literal: Kinds.NumericLiteralKind | Kinds.StringLiteralKind | Kinds.BooleanLiteralKind | Kinds.TemplateLiteralKind | Kinds.UnaryExpressionKind | Kinds.BigIntLiteralKind;
    }
    export interface TSUnionType extends Omit_2<TSType, "type"> {
        type: "TSUnionType";
        types: Kinds.TSTypeKind[];
    }
    export interface TSIntersectionType extends Omit_2<TSType, "type"> {
        type: "TSIntersectionType";
        types: Kinds.TSTypeKind[];
    }
    export interface TSConditionalType extends Omit_2<TSType, "type"> {
        type: "TSConditionalType";
        checkType: Kinds.TSTypeKind;
        extendsType: Kinds.TSTypeKind;
        trueType: Kinds.TSTypeKind;
        falseType: Kinds.TSTypeKind;
    }
    export interface TSInferType extends Omit_2<TSType, "type"> {
        type: "TSInferType";
        typeParameter: Kinds.TSTypeParameterKind;
    }
    export interface TSTypeParameter extends Omit_2<Identifier, "type" | "name"> {
        type: "TSTypeParameter";
        name: Kinds.IdentifierKind | string;
        constraint?: Kinds.TSTypeKind | undefined;
        default?: Kinds.TSTypeKind | undefined;
        const?: boolean;
        in?: boolean;
        out?: boolean;
    }
    export interface TSParenthesizedType extends Omit_2<TSType, "type"> {
        type: "TSParenthesizedType";
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSFunctionType extends Omit_2<TSType, "type">, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation {
        type: "TSFunctionType";
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
    }
    export interface TSConstructorType extends Omit_2<TSType, "type">, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation {
        type: "TSConstructorType";
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        abstract?: boolean;
    }
    export interface TSDeclareFunction extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters {
        type: "TSDeclareFunction";
        declare?: boolean;
        async?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        params: Kinds.PatternKind[];
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null;
        expression?: boolean;
    }
    export interface TSDeclareMethod extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters {
        type: "TSDeclareMethod";
        async?: boolean;
        generator?: boolean;
        params: Kinds.PatternKind[];
        abstract?: boolean;
        accessibility?: "public" | "private" | "protected" | undefined;
        static?: boolean;
        computed?: boolean;
        optional?: boolean;
        key: Kinds.IdentifierKind | Kinds.StringLiteralKind | Kinds.NumericLiteralKind | Kinds.ExpressionKind;
        kind?: "get" | "set" | "method" | "constructor";
        access?: "public" | "private" | "protected" | undefined;
        decorators?: Kinds.DecoratorKind[] | null;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null;
    }
    export interface TSMappedType extends Omit_2<TSType, "type"> {
        type: "TSMappedType";
        readonly?: boolean | "+" | "-";
        typeParameter: Kinds.TSTypeParameterKind;
        optional?: boolean | "+" | "-";
        typeAnnotation?: Kinds.TSTypeKind | null;
        key?: Kinds.IdentifierKind | undefined;
        constraint?: Kinds.TSTypeKind | undefined;
        nameType?: Kinds.TSTypeKind | null;
    }
    export interface TSTupleType extends Omit_2<TSType, "type"> {
        type: "TSTupleType";
        elementTypes: (Kinds.TSTypeKind | Kinds.TSNamedTupleMemberKind)[];
    }
    export interface TSNamedTupleMember extends Omit_2<TSType, "type"> {
        type: "TSNamedTupleMember";
        label: Kinds.IdentifierKind;
        optional?: boolean;
        elementType: Kinds.TSTypeKind;
    }
    export interface TSRestType extends Omit_2<TSType, "type"> {
        type: "TSRestType";
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSOptionalType extends Omit_2<TSType, "type"> {
        type: "TSOptionalType";
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSIndexedAccessType extends Omit_2<TSType, "type"> {
        type: "TSIndexedAccessType";
        objectType: Kinds.TSTypeKind;
        indexType: Kinds.TSTypeKind;
    }
    export interface TSTypeOperator extends Omit_2<TSType, "type"> {
        type: "TSTypeOperator";
        operator: string;
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSIndexSignature extends Omit_2<Declaration, "type">, TSHasOptionalTypeAnnotation {
        type: "TSIndexSignature";
        parameters: Kinds.IdentifierKind[];
        readonly?: boolean;
        accessibility?: "public" | "private" | "protected" | undefined;
        static?: boolean;
    }
    export interface TSPropertySignature extends Omit_2<Declaration, "type">, TSHasOptionalTypeAnnotation {
        type: "TSPropertySignature";
        key: Kinds.ExpressionKind;
        computed?: boolean;
        readonly?: boolean;
        optional?: boolean;
        initializer?: Kinds.ExpressionKind | null;
        accessibility?: "public" | "private" | "protected" | undefined;
        static?: boolean;
    }
    export interface TSMethodSignature extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation {
        type: "TSMethodSignature";
        key: Kinds.ExpressionKind;
        computed?: boolean;
        optional?: boolean;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        kind?: "method" | "get" | "set";
        accessibility?: "public" | "private" | "protected" | undefined;
        readonly?: boolean;
        static?: boolean;
    }
    export interface TSTypePredicate extends Omit_2<TSTypeAnnotation, "type" | "typeAnnotation">, Omit_2<TSType, "type"> {
        type: "TSTypePredicate";
        parameterName: Kinds.IdentifierKind | Kinds.TSThisTypeKind;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        asserts?: boolean;
    }
    export interface TSCallSignatureDeclaration extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation {
        type: "TSCallSignatureDeclaration";
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
    }
    export interface TSConstructSignatureDeclaration extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation {
        type: "TSConstructSignatureDeclaration";
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
    }
    export interface TSEnumMember extends Omit_2<Node, "type"> {
        type: "TSEnumMember";
        id: Kinds.IdentifierKind | Kinds.StringLiteralKind;
        initializer?: Kinds.ExpressionKind | null;
        computed?: boolean;
    }
    export interface TSTypeQuery extends Omit_2<TSType, "type"> {
        type: "TSTypeQuery";
        exprName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSImportTypeKind;
    }
    export interface TSImportType extends Omit_2<TSType, "type">, TSHasOptionalTypeParameterInstantiation {
        type: "TSImportType";
        argument: Kinds.StringLiteralKind;
        qualifier?: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | undefined;
        source?: Kinds.StringLiteralKind | undefined;
        options?: Kinds.ExpressionKind | null | undefined;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface TSTypeLiteral extends Omit_2<TSType, "type"> {
        type: "TSTypeLiteral";
        members: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
    }
    export interface TSTypeAssertion extends Omit_2<Expression, "type">, Omit_2<Pattern, "type"> {
        type: "TSTypeAssertion";
        typeAnnotation: Kinds.TSTypeKind;
        expression: Kinds.ExpressionKind;
        extra?: {
            parenthesized: boolean;
        } | null;
    }
    export interface TSInstantiationExpression extends Omit_2<Expression, "type">, TSHasOptionalTypeParameterInstantiation {
        type: "TSInstantiationExpression";
        expression: Kinds.ExpressionKind;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface TSEnumDeclaration extends Omit_2<Declaration, "type"> {
        type: "TSEnumDeclaration";
        id: Kinds.IdentifierKind;
        const?: boolean;
        declare?: boolean;
        members: Kinds.TSEnumMemberKind[];
        initializer?: Kinds.ExpressionKind | null;
        body?: Kinds.TSEnumBodyKind | undefined;
    }
    export interface TSTypeAliasDeclaration extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters {
        type: "TSTypeAliasDeclaration";
        id: Kinds.IdentifierKind;
        declare?: boolean;
        typeAnnotation: Kinds.TSTypeKind;
    }
    export interface TSModuleBlock extends Omit_2<Node, "type"> {
        type: "TSModuleBlock";
        body: Kinds.StatementKind[];
    }
    export interface TSModuleDeclaration extends Omit_2<Declaration, "type"> {
        type: "TSModuleDeclaration";
        id: Kinds.StringLiteralKind | Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        declare?: boolean;
        global?: boolean;
        body?: Kinds.TSModuleBlockKind | Kinds.TSModuleDeclarationKind | null;
        kind?: "global" | "module" | "namespace" | undefined;
    }
    export interface TSImportEqualsDeclaration extends Omit_2<Declaration, "type"> {
        type: "TSImportEqualsDeclaration";
        id: Kinds.IdentifierKind;
        isExport?: boolean;
        moduleReference: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSExternalModuleReferenceKind;
        importKind?: "type" | "value" | undefined;
    }
    export interface TSExternalModuleReference extends Omit_2<Declaration, "type"> {
        type: "TSExternalModuleReference";
        expression: Kinds.StringLiteralKind;
    }
    export interface TSExportAssignment extends Omit_2<Statement, "type"> {
        type: "TSExportAssignment";
        expression: Kinds.ExpressionKind;
    }
    export interface TSNamespaceExportDeclaration extends Omit_2<Declaration, "type"> {
        type: "TSNamespaceExportDeclaration";
        id: Kinds.IdentifierKind;
    }
    export interface TSInterfaceBody extends Omit_2<Node, "type"> {
        type: "TSInterfaceBody";
        body: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
    }
    export interface TSInterfaceDeclaration extends Omit_2<Declaration, "type">, TSHasOptionalTypeParameters {
        type: "TSInterfaceDeclaration";
        id: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        declare?: boolean;
        extends?: (Kinds.TSInterfaceHeritageKind | Kinds.TSExpressionWithTypeArgumentsKind)[] | null;
        body: Kinds.TSInterfaceBodyKind;
    }
    export interface TSParameterProperty extends Omit_2<Pattern, "type"> {
        type: "TSParameterProperty";
        accessibility?: "public" | "private" | "protected" | undefined;
        readonly?: boolean;
        parameter: Kinds.IdentifierKind | Kinds.AssignmentPatternKind;
        decorators?: Kinds.DecoratorKind[] | null;
        override?: boolean;
        static?: boolean;
    }
    export interface TSEnumBody extends Omit_2<Node, "type"> {
        type: "TSEnumBody";
        members: Kinds.TSEnumMemberKind[];
    }
    export interface TSInterfaceHeritage extends Omit_2<Node, "type"> {
        type: "TSInterfaceHeritage";
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface TSClassImplements extends Omit_2<Node, "type"> {
        type: "TSClassImplements";
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }
    export interface TSTemplateLiteralType extends Omit_2<TSType, "type"> {
        type: "TSTemplateLiteralType";
        quasis: Kinds.TemplateElementKind[];
        types: Kinds.TSTypeKind[];
    }
    export interface TSEmptyBodyFunctionExpression extends Omit_2<FunctionExpression, "type" | "id" | "params" | "body" | "declare" | "expression" | "returnType"> {
        type: "TSEmptyBodyFunctionExpression";
        id?: Kinds.IdentifierKind | null;
        params: Kinds.PatternKind[];
        body?: null;
        declare?: boolean;
        expression?: boolean;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
    }
    export interface TSAbstractMethodDefinition extends Omit_2<MethodDefinition, "type" | "value" | "accessibility" | "decorators" | "optional" | "override"> {
        type: "TSAbstractMethodDefinition";
        value: Kinds.TSEmptyBodyFunctionExpressionKind | Kinds.FunctionExpressionKind;
        accessibility?: "public" | "private" | "protected" | undefined;
        decorators?: Kinds.DecoratorKind[] | null;
        optional?: boolean;
        override?: boolean;
    }
    export interface TSAbstractPropertyDefinition extends Omit_2<PropertyDefinition, "type" | "value" | "accessibility" | "declare" | "definite" | "optional" | "override" | "readonly"> {
        type: "TSAbstractPropertyDefinition";
        value?: Kinds.ExpressionKind | null;
        accessibility?: "public" | "private" | "protected" | undefined;
        declare?: boolean;
        definite?: boolean;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
    }
    export type ASTNode = File | Program | Identifier | BlockStatement | EmptyStatement | ExpressionStatement | IfStatement | LabeledStatement | BreakStatement | ContinueStatement | WithStatement | SwitchStatement | SwitchCase | ReturnStatement | ThrowStatement | TryStatement | CatchClause | WhileStatement | DoWhileStatement | ForStatement | VariableDeclaration | ForInStatement | DebuggerStatement | FunctionDeclaration | FunctionExpression | VariableDeclarator | ThisExpression | ArrayExpression | ObjectExpression | Property | Literal | SequenceExpression | UnaryExpression | BinaryExpression | AssignmentExpression | MemberExpression | UpdateExpression | LogicalExpression | ConditionalExpression | NewExpression | CallExpression | RestElement | TypeAnnotation | TSTypeAnnotation | SpreadElementPattern | ArrowFunctionExpression | ForOfStatement | YieldExpression | GeneratorExpression | ComprehensionBlock | ComprehensionExpression | ObjectProperty | PropertyPattern | ObjectPattern | ArrayPattern | SpreadElement | AssignmentPattern | MethodDefinition | ClassPropertyDefinition | ClassProperty | StaticBlock | ClassBody | ClassDeclaration | ClassExpression | Super | ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportDeclaration | ExportNamedDeclaration | ExportSpecifier | ExportDefaultDeclaration | ExportAllDeclaration | TaggedTemplateExpression | TemplateLiteral | TemplateElement | MetaProperty | AwaitExpression | SpreadProperty | SpreadPropertyPattern | ImportExpression | ChainExpression | OptionalCallExpression | OptionalMemberExpression | PrivateIdentifier | Decorator | PrivateName | ClassPrivateProperty | ImportAttribute | RecordExpression | ObjectMethod | TupleExpression | ModuleExpression | JSXAttribute | JSXIdentifier | JSXNamespacedName | JSXExpressionContainer | JSXElement | JSXFragment | JSXMemberExpression | JSXSpreadAttribute | JSXEmptyExpression | JSXText | JSXSpreadChild | JSXOpeningElement | JSXClosingElement | JSXOpeningFragment | JSXClosingFragment | TypeParameterDeclaration | TSTypeParameterDeclaration | TypeParameterInstantiation | TSTypeParameterInstantiation | ClassImplements | TSExpressionWithTypeArguments | AnyTypeAnnotation | EmptyTypeAnnotation | MixedTypeAnnotation | VoidTypeAnnotation | SymbolTypeAnnotation | NumberTypeAnnotation | BigIntTypeAnnotation | NumberLiteralTypeAnnotation | NumericLiteralTypeAnnotation | BigIntLiteralTypeAnnotation | StringTypeAnnotation | StringLiteralTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullableTypeAnnotation | NullLiteralTypeAnnotation | NullTypeAnnotation | ThisTypeAnnotation | ExistsTypeAnnotation | ExistentialTypeParam | FunctionTypeAnnotation | FunctionTypeParam | ArrayTypeAnnotation | ObjectTypeAnnotation | ObjectTypeProperty | ObjectTypeSpreadProperty | ObjectTypeIndexer | ObjectTypeCallProperty | ObjectTypeInternalSlot | Variance | QualifiedTypeIdentifier | GenericTypeAnnotation | MemberTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType | UnionTypeAnnotation | IntersectionTypeAnnotation | TypeofTypeAnnotation | TypeParameter | PropertyDefinition | InterfaceTypeAnnotation | InterfaceExtends | InterfaceDeclaration | DeclareInterface | TypeAlias | DeclareTypeAlias | OpaqueType | DeclareOpaqueType | TypeCastExpression | TupleTypeAnnotation | DeclareVariable | DeclareFunction | DeclareClass | DeclareModule | DeclareModuleExports | DeclareExportDeclaration | ExportBatchSpecifier | DeclareExportAllDeclaration | InferredPredicate | DeclaredPredicate | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | ExportDeclaration | Block | Line | Noop | DoExpression | BindExpression | ParenthesizedExpression | ExportNamespaceSpecifier | ExportDefaultSpecifier | CommentBlock | CommentLine | Directive | DirectiveLiteral | InterpreterDirective | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ClassMethod | ClassPrivateMethod | ClassAccessorProperty | RestProperty | ForAwaitStatement | Import | V8IntrinsicIdentifier | TopicReference | TSQualifiedName | TSTypeReference | TSAsExpression | TSTypeCastExpression | TSSatisfiesExpression | TSNonNullExpression | TSAnyKeyword | TSBigIntKeyword | TSBooleanKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSIntrinsicKeyword | TSThisType | TSArrayType | TSLiteralType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSTypeParameter | TSParenthesizedType | TSFunctionType | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSMappedType | TSTupleType | TSNamedTupleMember | TSRestType | TSOptionalType | TSIndexedAccessType | TSTypeOperator | TSIndexSignature | TSPropertySignature | TSMethodSignature | TSTypePredicate | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSEnumMember | TSTypeQuery | TSImportType | TSTypeLiteral | TSTypeAssertion | TSInstantiationExpression | TSEnumDeclaration | TSTypeAliasDeclaration | TSModuleBlock | TSModuleDeclaration | TSImportEqualsDeclaration | TSExternalModuleReference | TSExportAssignment | TSNamespaceExportDeclaration | TSInterfaceBody | TSInterfaceDeclaration | TSParameterProperty | TSEnumBody | TSInterfaceHeritage | TSClassImplements | TSTemplateLiteralType | TSEmptyBodyFunctionExpression | TSAbstractMethodDefinition | TSAbstractPropertyDefinition;
    let Printable: Type<Printable>;
    let SourceLocation: Type<SourceLocation>;
    let Node: Type<Node>;
    let Comment: Type<Comment>;
    let Position: Type<Position>;
    let File: Type<File>;
    let Program: Type<Program>;
    let Statement: Type<Statement>;
    let Function: Type<Function>;
    let Expression: Type<Expression>;
    let Pattern: Type<Pattern>;
    let Identifier: Type<Identifier>;
    let BlockStatement: Type<BlockStatement>;
    let EmptyStatement: Type<EmptyStatement>;
    let ExpressionStatement: Type<ExpressionStatement>;
    let IfStatement: Type<IfStatement>;
    let LabeledStatement: Type<LabeledStatement>;
    let BreakStatement: Type<BreakStatement>;
    let ContinueStatement: Type<ContinueStatement>;
    let WithStatement: Type<WithStatement>;
    let SwitchStatement: Type<SwitchStatement>;
    let SwitchCase: Type<SwitchCase>;
    let ReturnStatement: Type<ReturnStatement>;
    let ThrowStatement: Type<ThrowStatement>;
    let TryStatement: Type<TryStatement>;
    let CatchClause: Type<CatchClause>;
    let WhileStatement: Type<WhileStatement>;
    let DoWhileStatement: Type<DoWhileStatement>;
    let ForStatement: Type<ForStatement>;
    let Declaration: Type<Declaration>;
    let VariableDeclaration: Type<VariableDeclaration>;
    let ForInStatement: Type<ForInStatement>;
    let DebuggerStatement: Type<DebuggerStatement>;
    let FunctionDeclaration: Type<FunctionDeclaration>;
    let FunctionExpression: Type<FunctionExpression>;
    let VariableDeclarator: Type<VariableDeclarator>;
    let ThisExpression: Type<ThisExpression>;
    let ArrayExpression: Type<ArrayExpression>;
    let ObjectExpression: Type<ObjectExpression>;
    let Property: Type<Property>;
    let Literal: Type<Literal>;
    let SequenceExpression: Type<SequenceExpression>;
    let UnaryExpression: Type<UnaryExpression>;
    let BinaryExpression: Type<BinaryExpression>;
    let AssignmentExpression: Type<AssignmentExpression>;
    let ChainElement: Type<ChainElement>;
    let MemberExpression: Type<MemberExpression>;
    let UpdateExpression: Type<UpdateExpression>;
    let LogicalExpression: Type<LogicalExpression>;
    let ConditionalExpression: Type<ConditionalExpression>;
    let NewExpression: Type<NewExpression>;
    let TSHasOptionalTypeParameterInstantiation: Type<TSHasOptionalTypeParameterInstantiation>;
    let CallExpression: Type<CallExpression>;
    let RestElement: Type<RestElement>;
    let TypeAnnotation: Type<TypeAnnotation>;
    let TSTypeAnnotation: Type<TSTypeAnnotation>;
    let SpreadElementPattern: Type<SpreadElementPattern>;
    let ArrowFunctionExpression: Type<ArrowFunctionExpression>;
    let ForOfStatement: Type<ForOfStatement>;
    let YieldExpression: Type<YieldExpression>;
    let GeneratorExpression: Type<GeneratorExpression>;
    let ComprehensionBlock: Type<ComprehensionBlock>;
    let ComprehensionExpression: Type<ComprehensionExpression>;
    let ObjectProperty: Type<ObjectProperty>;
    let PropertyPattern: Type<PropertyPattern>;
    let ObjectPattern: Type<ObjectPattern>;
    let ArrayPattern: Type<ArrayPattern>;
    let SpreadElement: Type<SpreadElement>;
    let AssignmentPattern: Type<AssignmentPattern>;
    let MethodDefinition: Type<MethodDefinition>;
    let ClassPropertyDefinition: Type<ClassPropertyDefinition>;
    let ClassProperty: Type<ClassProperty>;
    let StaticBlock: Type<StaticBlock>;
    let ClassBody: Type<ClassBody>;
    let ClassDeclaration: Type<ClassDeclaration>;
    let ClassExpression: Type<ClassExpression>;
    let Super: Type<Super>;
    let Specifier: Type<Specifier>;
    let ModuleSpecifier: Type<ModuleSpecifier>;
    let ImportSpecifier: Type<ImportSpecifier>;
    let ImportDefaultSpecifier: Type<ImportDefaultSpecifier>;
    let ImportNamespaceSpecifier: Type<ImportNamespaceSpecifier>;
    let ImportDeclaration: Type<ImportDeclaration>;
    let ExportNamedDeclaration: Type<ExportNamedDeclaration>;
    let ExportSpecifier: Type<ExportSpecifier>;
    let ExportDefaultDeclaration: Type<ExportDefaultDeclaration>;
    let ExportAllDeclaration: Type<ExportAllDeclaration>;
    let TaggedTemplateExpression: Type<TaggedTemplateExpression>;
    let TemplateLiteral: Type<TemplateLiteral>;
    let TemplateElement: Type<TemplateElement>;
    let MetaProperty: Type<MetaProperty>;
    let AwaitExpression: Type<AwaitExpression>;
    let SpreadProperty: Type<SpreadProperty>;
    let SpreadPropertyPattern: Type<SpreadPropertyPattern>;
    let ImportExpression: Type<ImportExpression>;
    let ChainExpression: Type<ChainExpression>;
    let OptionalCallExpression: Type<OptionalCallExpression>;
    let OptionalMemberExpression: Type<OptionalMemberExpression>;
    let PrivateIdentifier: Type<PrivateIdentifier>;
    let Decorator: Type<Decorator>;
    let PrivateName: Type<PrivateName>;
    let ClassPrivateProperty: Type<ClassPrivateProperty>;
    let ImportAttribute: Type<ImportAttribute>;
    let RecordExpression: Type<RecordExpression>;
    let ObjectMethod: Type<ObjectMethod>;
    let TupleExpression: Type<TupleExpression>;
    let ModuleExpression: Type<ModuleExpression>;
    let JSXAttribute: Type<JSXAttribute>;
    let JSXIdentifier: Type<JSXIdentifier>;
    let JSXNamespacedName: Type<JSXNamespacedName>;
    let JSXExpressionContainer: Type<JSXExpressionContainer>;
    let JSXElement: Type<JSXElement>;
    let JSXFragment: Type<JSXFragment>;
    let JSXMemberExpression: Type<JSXMemberExpression>;
    let JSXSpreadAttribute: Type<JSXSpreadAttribute>;
    let JSXEmptyExpression: Type<JSXEmptyExpression>;
    let JSXText: Type<JSXText>;
    let JSXSpreadChild: Type<JSXSpreadChild>;
    let JSXOpeningElement: Type<JSXOpeningElement>;
    let JSXClosingElement: Type<JSXClosingElement>;
    let JSXOpeningFragment: Type<JSXOpeningFragment>;
    let JSXClosingFragment: Type<JSXClosingFragment>;
    let TypeParameterDeclaration: Type<TypeParameterDeclaration>;
    let TSTypeParameterDeclaration: Type<TSTypeParameterDeclaration>;
    let TypeParameterInstantiation: Type<TypeParameterInstantiation>;
    let TSTypeParameterInstantiation: Type<TSTypeParameterInstantiation>;
    let ClassImplements: Type<ClassImplements>;
    let TSType: Type<TSType>;
    let TSExpressionWithTypeArguments: Type<TSExpressionWithTypeArguments>;
    let Flow: Type<Flow>;
    let FlowType: Type<FlowType>;
    let AnyTypeAnnotation: Type<AnyTypeAnnotation>;
    let EmptyTypeAnnotation: Type<EmptyTypeAnnotation>;
    let MixedTypeAnnotation: Type<MixedTypeAnnotation>;
    let VoidTypeAnnotation: Type<VoidTypeAnnotation>;
    let SymbolTypeAnnotation: Type<SymbolTypeAnnotation>;
    let NumberTypeAnnotation: Type<NumberTypeAnnotation>;
    let BigIntTypeAnnotation: Type<BigIntTypeAnnotation>;
    let NumberLiteralTypeAnnotation: Type<NumberLiteralTypeAnnotation>;
    let NumericLiteralTypeAnnotation: Type<NumericLiteralTypeAnnotation>;
    let BigIntLiteralTypeAnnotation: Type<BigIntLiteralTypeAnnotation>;
    let StringTypeAnnotation: Type<StringTypeAnnotation>;
    let StringLiteralTypeAnnotation: Type<StringLiteralTypeAnnotation>;
    let BooleanTypeAnnotation: Type<BooleanTypeAnnotation>;
    let BooleanLiteralTypeAnnotation: Type<BooleanLiteralTypeAnnotation>;
    let NullableTypeAnnotation: Type<NullableTypeAnnotation>;
    let NullLiteralTypeAnnotation: Type<NullLiteralTypeAnnotation>;
    let NullTypeAnnotation: Type<NullTypeAnnotation>;
    let ThisTypeAnnotation: Type<ThisTypeAnnotation>;
    let ExistsTypeAnnotation: Type<ExistsTypeAnnotation>;
    let ExistentialTypeParam: Type<ExistentialTypeParam>;
    let FunctionTypeAnnotation: Type<FunctionTypeAnnotation>;
    let FunctionTypeParam: Type<FunctionTypeParam>;
    let ArrayTypeAnnotation: Type<ArrayTypeAnnotation>;
    let ObjectTypeAnnotation: Type<ObjectTypeAnnotation>;
    let ObjectTypeProperty: Type<ObjectTypeProperty>;
    let ObjectTypeSpreadProperty: Type<ObjectTypeSpreadProperty>;
    let ObjectTypeIndexer: Type<ObjectTypeIndexer>;
    let ObjectTypeCallProperty: Type<ObjectTypeCallProperty>;
    let ObjectTypeInternalSlot: Type<ObjectTypeInternalSlot>;
    let Variance: Type<Variance>;
    let QualifiedTypeIdentifier: Type<QualifiedTypeIdentifier>;
    let GenericTypeAnnotation: Type<GenericTypeAnnotation>;
    let MemberTypeAnnotation: Type<MemberTypeAnnotation>;
    let IndexedAccessType: Type<IndexedAccessType>;
    let OptionalIndexedAccessType: Type<OptionalIndexedAccessType>;
    let UnionTypeAnnotation: Type<UnionTypeAnnotation>;
    let IntersectionTypeAnnotation: Type<IntersectionTypeAnnotation>;
    let TypeofTypeAnnotation: Type<TypeofTypeAnnotation>;
    let TypeParameter: Type<TypeParameter>;
    let PropertyDefinition: Type<PropertyDefinition>;
    let InterfaceTypeAnnotation: Type<InterfaceTypeAnnotation>;
    let InterfaceExtends: Type<InterfaceExtends>;
    let InterfaceDeclaration: Type<InterfaceDeclaration>;
    let DeclareInterface: Type<DeclareInterface>;
    let TypeAlias: Type<TypeAlias>;
    let DeclareTypeAlias: Type<DeclareTypeAlias>;
    let OpaqueType: Type<OpaqueType>;
    let DeclareOpaqueType: Type<DeclareOpaqueType>;
    let TypeCastExpression: Type<TypeCastExpression>;
    let TupleTypeAnnotation: Type<TupleTypeAnnotation>;
    let DeclareVariable: Type<DeclareVariable>;
    let DeclareFunction: Type<DeclareFunction>;
    let FlowPredicate: Type<FlowPredicate>;
    let DeclareClass: Type<DeclareClass>;
    let DeclareModule: Type<DeclareModule>;
    let DeclareModuleExports: Type<DeclareModuleExports>;
    let DeclareExportDeclaration: Type<DeclareExportDeclaration>;
    let ExportBatchSpecifier: Type<ExportBatchSpecifier>;
    let DeclareExportAllDeclaration: Type<DeclareExportAllDeclaration>;
    let InferredPredicate: Type<InferredPredicate>;
    let DeclaredPredicate: Type<DeclaredPredicate>;
    let EnumDeclaration: Type<EnumDeclaration>;
    let EnumBooleanBody: Type<EnumBooleanBody>;
    let EnumNumberBody: Type<EnumNumberBody>;
    let EnumStringBody: Type<EnumStringBody>;
    let EnumSymbolBody: Type<EnumSymbolBody>;
    let EnumBooleanMember: Type<EnumBooleanMember>;
    let EnumNumberMember: Type<EnumNumberMember>;
    let EnumStringMember: Type<EnumStringMember>;
    let EnumDefaultedMember: Type<EnumDefaultedMember>;
    let ExportDeclaration: Type<ExportDeclaration>;
    let Block: Type<Block>;
    let Line: Type<Line>;
    let Noop: Type<Noop>;
    let DoExpression: Type<DoExpression>;
    let BindExpression: Type<BindExpression>;
    let ParenthesizedExpression: Type<ParenthesizedExpression>;
    let ExportNamespaceSpecifier: Type<ExportNamespaceSpecifier>;
    let ExportDefaultSpecifier: Type<ExportDefaultSpecifier>;
    let CommentBlock: Type<CommentBlock>;
    let CommentLine: Type<CommentLine>;
    let Directive: Type<Directive>;
    let DirectiveLiteral: Type<DirectiveLiteral>;
    let InterpreterDirective: Type<InterpreterDirective>;
    let StringLiteral: Type<StringLiteral>;
    let NumericLiteral: Type<NumericLiteral>;
    let BigIntLiteral: Type<BigIntLiteral>;
    let DecimalLiteral: Type<DecimalLiteral>;
    let NullLiteral: Type<NullLiteral>;
    let BooleanLiteral: Type<BooleanLiteral>;
    let RegExpLiteral: Type<RegExpLiteral>;
    let ClassMethod: Type<ClassMethod>;
    let ClassPrivateMethod: Type<ClassPrivateMethod>;
    let TSHasOptionalTypeAnnotation: Type<TSHasOptionalTypeAnnotation>;
    let ClassAccessorProperty: Type<ClassAccessorProperty>;
    let RestProperty: Type<RestProperty>;
    let ForAwaitStatement: Type<ForAwaitStatement>;
    let Import: Type<Import>;
    let V8IntrinsicIdentifier: Type<V8IntrinsicIdentifier>;
    let TopicReference: Type<TopicReference>;
    let TSQualifiedName: Type<TSQualifiedName>;
    let TSTypeReference: Type<TSTypeReference>;
    let TSHasOptionalTypeParameters: Type<TSHasOptionalTypeParameters>;
    let TSAsExpression: Type<TSAsExpression>;
    let TSTypeCastExpression: Type<TSTypeCastExpression>;
    let TSSatisfiesExpression: Type<TSSatisfiesExpression>;
    let TSNonNullExpression: Type<TSNonNullExpression>;
    let TSAnyKeyword: Type<TSAnyKeyword>;
    let TSBigIntKeyword: Type<TSBigIntKeyword>;
    let TSBooleanKeyword: Type<TSBooleanKeyword>;
    let TSNeverKeyword: Type<TSNeverKeyword>;
    let TSNullKeyword: Type<TSNullKeyword>;
    let TSNumberKeyword: Type<TSNumberKeyword>;
    let TSObjectKeyword: Type<TSObjectKeyword>;
    let TSStringKeyword: Type<TSStringKeyword>;
    let TSSymbolKeyword: Type<TSSymbolKeyword>;
    let TSUndefinedKeyword: Type<TSUndefinedKeyword>;
    let TSUnknownKeyword: Type<TSUnknownKeyword>;
    let TSVoidKeyword: Type<TSVoidKeyword>;
    let TSIntrinsicKeyword: Type<TSIntrinsicKeyword>;
    let TSThisType: Type<TSThisType>;
    let TSArrayType: Type<TSArrayType>;
    let TSLiteralType: Type<TSLiteralType>;
    let TSUnionType: Type<TSUnionType>;
    let TSIntersectionType: Type<TSIntersectionType>;
    let TSConditionalType: Type<TSConditionalType>;
    let TSInferType: Type<TSInferType>;
    let TSTypeParameter: Type<TSTypeParameter>;
    let TSParenthesizedType: Type<TSParenthesizedType>;
    let TSFunctionType: Type<TSFunctionType>;
    let TSConstructorType: Type<TSConstructorType>;
    let TSDeclareFunction: Type<TSDeclareFunction>;
    let TSDeclareMethod: Type<TSDeclareMethod>;
    let TSMappedType: Type<TSMappedType>;
    let TSTupleType: Type<TSTupleType>;
    let TSNamedTupleMember: Type<TSNamedTupleMember>;
    let TSRestType: Type<TSRestType>;
    let TSOptionalType: Type<TSOptionalType>;
    let TSIndexedAccessType: Type<TSIndexedAccessType>;
    let TSTypeOperator: Type<TSTypeOperator>;
    let TSIndexSignature: Type<TSIndexSignature>;
    let TSPropertySignature: Type<TSPropertySignature>;
    let TSMethodSignature: Type<TSMethodSignature>;
    let TSTypePredicate: Type<TSTypePredicate>;
    let TSCallSignatureDeclaration: Type<TSCallSignatureDeclaration>;
    let TSConstructSignatureDeclaration: Type<TSConstructSignatureDeclaration>;
    let TSEnumMember: Type<TSEnumMember>;
    let TSTypeQuery: Type<TSTypeQuery>;
    let TSImportType: Type<TSImportType>;
    let TSTypeLiteral: Type<TSTypeLiteral>;
    let TSTypeAssertion: Type<TSTypeAssertion>;
    let TSInstantiationExpression: Type<TSInstantiationExpression>;
    let TSEnumDeclaration: Type<TSEnumDeclaration>;
    let TSTypeAliasDeclaration: Type<TSTypeAliasDeclaration>;
    let TSModuleBlock: Type<TSModuleBlock>;
    let TSModuleDeclaration: Type<TSModuleDeclaration>;
    let TSImportEqualsDeclaration: Type<TSImportEqualsDeclaration>;
    let TSExternalModuleReference: Type<TSExternalModuleReference>;
    let TSExportAssignment: Type<TSExportAssignment>;
    let TSNamespaceExportDeclaration: Type<TSNamespaceExportDeclaration>;
    let TSInterfaceBody: Type<TSInterfaceBody>;
    let TSInterfaceDeclaration: Type<TSInterfaceDeclaration>;
    let TSParameterProperty: Type<TSParameterProperty>;
    let TSEnumBody: Type<TSEnumBody>;
    let TSInterfaceHeritage: Type<TSInterfaceHeritage>;
    let TSClassImplements: Type<TSClassImplements>;
    let TSTemplateLiteralType: Type<TSTemplateLiteralType>;
    let TSEmptyBodyFunctionExpression: Type<TSEmptyBodyFunctionExpression>;
    let TSAbstractMethodDefinition: Type<TSAbstractMethodDefinition>;
    let TSAbstractPropertyDefinition: Type<TSAbstractPropertyDefinition>;
}

/**
 * Type of namespaces.
 * @public
 */
declare type Namespace = typeof NS.HTML | typeof NS.MathML | typeof NS.SVG | typeof NS.XLink | typeof NS.XML | typeof NS.XMLNS;

/** @public */
declare interface NewExpressionBuilder {
    (callee: Kinds.ExpressionKind, argumentsParam: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[]): namedTypes.NewExpression;
    from(params: {
        arguments: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[];
        callee: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeArguments?: null | Kinds.TypeParameterInstantiationKind;
    }): namedTypes.NewExpression;
}

/** @public */
declare type NewExpressionKind = namedTypes.NewExpression;

/**
 * The union type for all nodes.
 * @public
 */
declare type Node_2 = Exclude<namedTypes.ASTNode & HasParent, namedTypes.Program | namedTypes.File> | VNode | VForExpression | VOnExpression | VSlotScopeExpression | VFilterSequenceExpression | VFilter | VDocumentFragment;

/** @public */
declare type NodeKind = namedTypes.File | namedTypes.Program | namedTypes.Identifier | namedTypes.BlockStatement | namedTypes.EmptyStatement | namedTypes.ExpressionStatement | namedTypes.IfStatement | namedTypes.LabeledStatement | namedTypes.BreakStatement | namedTypes.ContinueStatement | namedTypes.WithStatement | namedTypes.SwitchStatement | namedTypes.SwitchCase | namedTypes.ReturnStatement | namedTypes.ThrowStatement | namedTypes.TryStatement | namedTypes.CatchClause | namedTypes.WhileStatement | namedTypes.DoWhileStatement | namedTypes.ForStatement | namedTypes.VariableDeclaration | namedTypes.ForInStatement | namedTypes.DebuggerStatement | namedTypes.FunctionDeclaration | namedTypes.FunctionExpression | namedTypes.VariableDeclarator | namedTypes.ThisExpression | namedTypes.ArrayExpression | namedTypes.ObjectExpression | namedTypes.Property | namedTypes.Literal | namedTypes.SequenceExpression | namedTypes.UnaryExpression | namedTypes.BinaryExpression | namedTypes.AssignmentExpression | namedTypes.MemberExpression | namedTypes.UpdateExpression | namedTypes.LogicalExpression | namedTypes.ConditionalExpression | namedTypes.NewExpression | namedTypes.CallExpression | namedTypes.RestElement | namedTypes.TypeAnnotation | namedTypes.TSTypeAnnotation | namedTypes.SpreadElementPattern | namedTypes.ArrowFunctionExpression | namedTypes.ForOfStatement | namedTypes.YieldExpression | namedTypes.GeneratorExpression | namedTypes.ComprehensionBlock | namedTypes.ComprehensionExpression | namedTypes.ObjectProperty | namedTypes.PropertyPattern | namedTypes.ObjectPattern | namedTypes.ArrayPattern | namedTypes.SpreadElement | namedTypes.AssignmentPattern | namedTypes.MethodDefinition | namedTypes.ClassPropertyDefinition | namedTypes.ClassProperty | namedTypes.StaticBlock | namedTypes.ClassBody | namedTypes.ClassDeclaration | namedTypes.ClassExpression | namedTypes.Super | namedTypes.ImportSpecifier | namedTypes.ImportDefaultSpecifier | namedTypes.ImportNamespaceSpecifier | namedTypes.ImportDeclaration | namedTypes.ExportNamedDeclaration | namedTypes.ExportSpecifier | namedTypes.ExportDefaultDeclaration | namedTypes.ExportAllDeclaration | namedTypes.TaggedTemplateExpression | namedTypes.TemplateLiteral | namedTypes.TemplateElement | namedTypes.MetaProperty | namedTypes.AwaitExpression | namedTypes.SpreadProperty | namedTypes.SpreadPropertyPattern | namedTypes.ImportExpression | namedTypes.ChainExpression | namedTypes.OptionalCallExpression | namedTypes.OptionalMemberExpression | namedTypes.PrivateIdentifier | namedTypes.Decorator | namedTypes.PrivateName | namedTypes.ClassPrivateProperty | namedTypes.ImportAttribute | namedTypes.RecordExpression | namedTypes.ObjectMethod | namedTypes.TupleExpression | namedTypes.ModuleExpression | namedTypes.JSXAttribute | namedTypes.JSXIdentifier | namedTypes.JSXNamespacedName | namedTypes.JSXExpressionContainer | namedTypes.JSXElement | namedTypes.JSXFragment | namedTypes.JSXMemberExpression | namedTypes.JSXSpreadAttribute | namedTypes.JSXEmptyExpression | namedTypes.JSXText | namedTypes.JSXSpreadChild | namedTypes.JSXOpeningElement | namedTypes.JSXClosingElement | namedTypes.JSXOpeningFragment | namedTypes.JSXClosingFragment | namedTypes.TypeParameterDeclaration | namedTypes.TSTypeParameterDeclaration | namedTypes.TypeParameterInstantiation | namedTypes.TSTypeParameterInstantiation | namedTypes.ClassImplements | namedTypes.TSExpressionWithTypeArguments | namedTypes.AnyTypeAnnotation | namedTypes.EmptyTypeAnnotation | namedTypes.MixedTypeAnnotation | namedTypes.VoidTypeAnnotation | namedTypes.SymbolTypeAnnotation | namedTypes.NumberTypeAnnotation | namedTypes.BigIntTypeAnnotation | namedTypes.NumberLiteralTypeAnnotation | namedTypes.NumericLiteralTypeAnnotation | namedTypes.BigIntLiteralTypeAnnotation | namedTypes.StringTypeAnnotation | namedTypes.StringLiteralTypeAnnotation | namedTypes.BooleanTypeAnnotation | namedTypes.BooleanLiteralTypeAnnotation | namedTypes.NullableTypeAnnotation | namedTypes.NullLiteralTypeAnnotation | namedTypes.NullTypeAnnotation | namedTypes.ThisTypeAnnotation | namedTypes.ExistsTypeAnnotation | namedTypes.ExistentialTypeParam | namedTypes.FunctionTypeAnnotation | namedTypes.FunctionTypeParam | namedTypes.ArrayTypeAnnotation | namedTypes.ObjectTypeAnnotation | namedTypes.ObjectTypeProperty | namedTypes.ObjectTypeSpreadProperty | namedTypes.ObjectTypeIndexer | namedTypes.ObjectTypeCallProperty | namedTypes.ObjectTypeInternalSlot | namedTypes.Variance | namedTypes.QualifiedTypeIdentifier | namedTypes.GenericTypeAnnotation | namedTypes.MemberTypeAnnotation | namedTypes.IndexedAccessType | namedTypes.OptionalIndexedAccessType | namedTypes.UnionTypeAnnotation | namedTypes.IntersectionTypeAnnotation | namedTypes.TypeofTypeAnnotation | namedTypes.TypeParameter | namedTypes.PropertyDefinition | namedTypes.InterfaceTypeAnnotation | namedTypes.InterfaceExtends | namedTypes.InterfaceDeclaration | namedTypes.DeclareInterface | namedTypes.TypeAlias | namedTypes.DeclareTypeAlias | namedTypes.OpaqueType | namedTypes.DeclareOpaqueType | namedTypes.TypeCastExpression | namedTypes.TupleTypeAnnotation | namedTypes.DeclareVariable | namedTypes.DeclareFunction | namedTypes.DeclareClass | namedTypes.DeclareModule | namedTypes.DeclareModuleExports | namedTypes.DeclareExportDeclaration | namedTypes.ExportBatchSpecifier | namedTypes.DeclareExportAllDeclaration | namedTypes.InferredPredicate | namedTypes.DeclaredPredicate | namedTypes.EnumDeclaration | namedTypes.ExportDeclaration | namedTypes.Noop | namedTypes.DoExpression | namedTypes.BindExpression | namedTypes.ParenthesizedExpression | namedTypes.ExportNamespaceSpecifier | namedTypes.ExportDefaultSpecifier | namedTypes.Directive | namedTypes.DirectiveLiteral | namedTypes.InterpreterDirective | namedTypes.StringLiteral | namedTypes.NumericLiteral | namedTypes.BigIntLiteral | namedTypes.DecimalLiteral | namedTypes.NullLiteral | namedTypes.BooleanLiteral | namedTypes.RegExpLiteral | namedTypes.ClassMethod | namedTypes.ClassPrivateMethod | namedTypes.ClassAccessorProperty | namedTypes.RestProperty | namedTypes.ForAwaitStatement | namedTypes.Import | namedTypes.V8IntrinsicIdentifier | namedTypes.TopicReference | namedTypes.TSQualifiedName | namedTypes.TSTypeReference | namedTypes.TSAsExpression | namedTypes.TSTypeCastExpression | namedTypes.TSSatisfiesExpression | namedTypes.TSNonNullExpression | namedTypes.TSAnyKeyword | namedTypes.TSBigIntKeyword | namedTypes.TSBooleanKeyword | namedTypes.TSNeverKeyword | namedTypes.TSNullKeyword | namedTypes.TSNumberKeyword | namedTypes.TSObjectKeyword | namedTypes.TSStringKeyword | namedTypes.TSSymbolKeyword | namedTypes.TSUndefinedKeyword | namedTypes.TSUnknownKeyword | namedTypes.TSVoidKeyword | namedTypes.TSIntrinsicKeyword | namedTypes.TSThisType | namedTypes.TSArrayType | namedTypes.TSLiteralType | namedTypes.TSUnionType | namedTypes.TSIntersectionType | namedTypes.TSConditionalType | namedTypes.TSInferType | namedTypes.TSTypeParameter | namedTypes.TSParenthesizedType | namedTypes.TSFunctionType | namedTypes.TSConstructorType | namedTypes.TSDeclareFunction | namedTypes.TSDeclareMethod | namedTypes.TSMappedType | namedTypes.TSTupleType | namedTypes.TSNamedTupleMember | namedTypes.TSRestType | namedTypes.TSOptionalType | namedTypes.TSIndexedAccessType | namedTypes.TSTypeOperator | namedTypes.TSIndexSignature | namedTypes.TSPropertySignature | namedTypes.TSMethodSignature | namedTypes.TSTypePredicate | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration | namedTypes.TSEnumMember | namedTypes.TSTypeQuery | namedTypes.TSImportType | namedTypes.TSTypeLiteral | namedTypes.TSTypeAssertion | namedTypes.TSInstantiationExpression | namedTypes.TSEnumDeclaration | namedTypes.TSTypeAliasDeclaration | namedTypes.TSModuleBlock | namedTypes.TSModuleDeclaration | namedTypes.TSImportEqualsDeclaration | namedTypes.TSExternalModuleReference | namedTypes.TSExportAssignment | namedTypes.TSNamespaceExportDeclaration | namedTypes.TSInterfaceBody | namedTypes.TSInterfaceDeclaration | namedTypes.TSParameterProperty | namedTypes.TSEnumBody | namedTypes.TSInterfaceHeritage | namedTypes.TSClassImplements | namedTypes.TSTemplateLiteralType | namedTypes.TSEmptyBodyFunctionExpression | namedTypes.TSAbstractMethodDefinition | namedTypes.TSAbstractPropertyDefinition;

declare interface NodePath<N = any, V = any> extends Path<V> {
    node: N;
    parent: any;
    scope: Scope | null;
    replace: Path['replace'];
    prune(...args: any[]): any;
    _computeNode(): any;
    _computeParent(): any;
    _computeScope(): Scope | null;
    getValueProperty(name: any): any;
    needsParens(assumeExpressionContext?: boolean): boolean;
    canBeFirstInStatement(): boolean;
    firstInStatement(): boolean;
}

/** @public */
declare interface NoopBuilder {
    (): namedTypes.Noop;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.Noop;
}

/** @public */
declare type NoopKind = namedTypes.Noop;

/**
 * @public
 */
declare const NS: Readonly<{
    HTML: "http://www.w3.org/1999/xhtml";
    MathML: "http://www.w3.org/1998/Math/MathML";
    SVG: "http://www.w3.org/2000/svg";
    XLink: "http://www.w3.org/1999/xlink";
    XML: "http://www.w3.org/XML/1998/namespace";
    XMLNS: "http://www.w3.org/2000/xmlns/";
}>;

/** @public */
declare interface NullableTypeAnnotationBuilder {
    (typeAnnotation: Kinds.FlowTypeKind): namedTypes.NullableTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.FlowTypeKind;
    }): namedTypes.NullableTypeAnnotation;
}

/** @public */
declare type NullableTypeAnnotationKind = namedTypes.NullableTypeAnnotation;

/** @public */
declare interface NullLiteralBuilder {
    (): namedTypes.NullLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value?: null;
    }): namedTypes.NullLiteral;
}

/** @public */
declare type NullLiteralKind = namedTypes.NullLiteral;

/** @public */
declare interface NullLiteralTypeAnnotationBuilder {
    (): namedTypes.NullLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.NullLiteralTypeAnnotation;
}

/** @public */
declare type NullLiteralTypeAnnotationKind = namedTypes.NullLiteralTypeAnnotation;

/** @public */
declare interface NullTypeAnnotationBuilder {
    (): namedTypes.NullTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.NullTypeAnnotation;
}

/** @public */
declare type NullTypeAnnotationKind = namedTypes.NullTypeAnnotation;

/** @public */
declare interface NumberLiteralTypeAnnotationBuilder {
    (value: number, raw: string): namedTypes.NumberLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw: string;
        value: number;
    }): namedTypes.NumberLiteralTypeAnnotation;
}

/** @public */
declare type NumberLiteralTypeAnnotationKind = namedTypes.NumberLiteralTypeAnnotation;

/** @public */
declare interface NumberTypeAnnotationBuilder {
    (): namedTypes.NumberTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.NumberTypeAnnotation;
}

/** @public */
declare type NumberTypeAnnotationKind = namedTypes.NumberTypeAnnotation;

/** @public */
declare interface NumericLiteralBuilder {
    (value: number): namedTypes.NumericLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        extra?: {
            rawValue: number;
            raw: string;
        };
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: number;
    }): namedTypes.NumericLiteral;
}

/** @public */
declare type NumericLiteralKind = namedTypes.NumericLiteral;

/** @public */
declare interface NumericLiteralTypeAnnotationBuilder {
    (value: number, raw: string): namedTypes.NumericLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw: string;
        value: number;
    }): namedTypes.NumericLiteralTypeAnnotation;
}

/** @public */
declare type NumericLiteralTypeAnnotationKind = namedTypes.NumericLiteralTypeAnnotation;

/** @public */
declare interface ObjectExpressionBuilder {
    (properties: (Kinds.PropertyKind | Kinds.ObjectMethodKind | Kinds.ObjectPropertyKind | Kinds.SpreadPropertyKind | Kinds.SpreadElementKind)[]): namedTypes.ObjectExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        properties: (Kinds.PropertyKind | Kinds.ObjectMethodKind | Kinds.ObjectPropertyKind | Kinds.SpreadPropertyKind | Kinds.SpreadElementKind)[];
    }): namedTypes.ObjectExpression;
}

/** @public */
declare type ObjectExpressionKind = namedTypes.ObjectExpression;

/** @public */
declare interface ObjectMethodBuilder {
    (kind: "method" | "get" | "set", key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, params: Kinds.PatternKind[], body: Kinds.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
    from(params: {
        accessibility?: Kinds.LiteralKind | null;
        async?: boolean;
        body: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        defaults?: (Kinds.ExpressionKind | null)[];
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        kind: "method" | "get" | "set";
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.ObjectMethod;
}

/** @public */
declare type ObjectMethodKind = namedTypes.ObjectMethod;

/** @public */
declare interface ObjectPatternBuilder {
    (properties: (Kinds.PropertyKind | Kinds.PropertyPatternKind | Kinds.SpreadPropertyPatternKind | Kinds.SpreadPropertyKind | Kinds.ObjectPropertyKind | Kinds.RestPropertyKind | Kinds.RestElementKind)[]): namedTypes.ObjectPattern;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        properties: (Kinds.PropertyKind | Kinds.PropertyPatternKind | Kinds.SpreadPropertyPatternKind | Kinds.SpreadPropertyKind | Kinds.ObjectPropertyKind | Kinds.RestPropertyKind | Kinds.RestElementKind)[];
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.ObjectPattern;
}

/** @public */
declare type ObjectPatternKind = namedTypes.ObjectPattern;

/** @public */
declare interface ObjectPropertyBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, value: Kinds.ExpressionKind | Kinds.PatternKind): namedTypes.ObjectProperty;
    from(params: {
        accessibility?: Kinds.LiteralKind | null;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        shorthand?: boolean;
        value: Kinds.ExpressionKind | Kinds.PatternKind;
    }): namedTypes.ObjectProperty;
}

/** @public */
declare type ObjectPropertyKind = namedTypes.ObjectProperty;

declare class ObjectType<T> extends BaseType<T> {
    readonly fields: Field<any>[];
    readonly kind: "ObjectType";
    constructor(fields: Field<any>[]);
    toString(): string;
    check(value: any, deep?: Deep): value is T;
}

/** @public */
declare interface ObjectTypeAnnotationBuilder {
    (properties: (Kinds.ObjectTypePropertyKind | Kinds.ObjectTypeSpreadPropertyKind)[], indexers?: Kinds.ObjectTypeIndexerKind[], callProperties?: Kinds.ObjectTypeCallPropertyKind[]): namedTypes.ObjectTypeAnnotation;
    from(params: {
        callProperties?: Kinds.ObjectTypeCallPropertyKind[];
        comments?: Kinds.CommentKind[] | null;
        exact?: boolean;
        indexers?: Kinds.ObjectTypeIndexerKind[];
        inexact?: boolean | undefined;
        internalSlots?: Kinds.ObjectTypeInternalSlotKind[];
        loc?: Kinds.SourceLocationKind | null;
        properties: (Kinds.ObjectTypePropertyKind | Kinds.ObjectTypeSpreadPropertyKind)[];
    }): namedTypes.ObjectTypeAnnotation;
}

/** @public */
declare type ObjectTypeAnnotationKind = namedTypes.ObjectTypeAnnotation;

/** @public */
declare interface ObjectTypeCallPropertyBuilder {
    (value: Kinds.FunctionTypeAnnotationKind): namedTypes.ObjectTypeCallProperty;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        static?: boolean;
        value: Kinds.FunctionTypeAnnotationKind;
    }): namedTypes.ObjectTypeCallProperty;
}

/** @public */
declare type ObjectTypeCallPropertyKind = namedTypes.ObjectTypeCallProperty;

/** @public */
declare interface ObjectTypeIndexerBuilder {
    (id: Kinds.IdentifierKind, key: Kinds.FlowTypeKind, value: Kinds.FlowTypeKind): namedTypes.ObjectTypeIndexer;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        key: Kinds.FlowTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        static?: boolean;
        value: Kinds.FlowTypeKind;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.ObjectTypeIndexer;
}

/** @public */
declare type ObjectTypeIndexerKind = namedTypes.ObjectTypeIndexer;

/** @public */
declare interface ObjectTypeInternalSlotBuilder {
    (id: Kinds.IdentifierKind, value: Kinds.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): namedTypes.ObjectTypeInternalSlot;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        method: boolean;
        optional: boolean;
        static: boolean;
        value: Kinds.FlowTypeKind;
    }): namedTypes.ObjectTypeInternalSlot;
}

/** @public */
declare type ObjectTypeInternalSlotKind = namedTypes.ObjectTypeInternalSlot;

/** @public */
declare interface ObjectTypePropertyBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind, value: Kinds.FlowTypeKind, optional: boolean): namedTypes.ObjectTypeProperty;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        key: Kinds.LiteralKind | Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        optional: boolean;
        value: Kinds.FlowTypeKind;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.ObjectTypeProperty;
}

/** @public */
declare type ObjectTypePropertyKind = namedTypes.ObjectTypeProperty;

/** @public */
declare interface ObjectTypeSpreadPropertyBuilder {
    (argument: Kinds.FlowTypeKind): namedTypes.ObjectTypeSpreadProperty;
    from(params: {
        argument: Kinds.FlowTypeKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ObjectTypeSpreadProperty;
}

/** @public */
declare type ObjectTypeSpreadPropertyKind = namedTypes.ObjectTypeSpreadProperty;

declare type Omit_2<T, K> = Pick<T, Exclude<keyof T, K>>;

/** @public */
declare interface OpaqueTypeBuilder {
    (id: Kinds.IdentifierKind, typeParameters: Kinds.TypeParameterDeclarationKind | null, impltype: Kinds.FlowTypeKind, supertype: Kinds.FlowTypeKind | null): namedTypes.OpaqueType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        impltype: Kinds.FlowTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        supertype: Kinds.FlowTypeKind | null;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.OpaqueType;
}

/** @public */
declare type OpaqueTypeKind = namedTypes.OpaqueType | namedTypes.DeclareOpaqueType;

/** @public */
declare interface OptionalCallExpressionBuilder {
    (callee: Kinds.ExpressionKind, argumentsParam: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[], optional?: boolean): namedTypes.OptionalCallExpression;
    from(params: {
        arguments: (Kinds.ExpressionKind | Kinds.SpreadElementKind)[];
        callee: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        typeArguments?: null | Kinds.TypeParameterInstantiationKind;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.OptionalCallExpression;
}

/** @public */
declare type OptionalCallExpressionKind = namedTypes.OptionalCallExpression;

/** @public */
declare interface OptionalIndexedAccessTypeBuilder {
    (objectType: Kinds.FlowTypeKind, indexType: Kinds.FlowTypeKind, optional: boolean): namedTypes.OptionalIndexedAccessType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        indexType: Kinds.FlowTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        objectType: Kinds.FlowTypeKind;
        optional: boolean;
    }): namedTypes.OptionalIndexedAccessType;
}

/** @public */
declare type OptionalIndexedAccessTypeKind = namedTypes.OptionalIndexedAccessType;

/** @public */
declare interface OptionalMemberExpressionBuilder {
    (object: Kinds.ExpressionKind, property: Kinds.IdentifierKind | Kinds.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.ExpressionKind;
        optional?: boolean;
        property: Kinds.IdentifierKind | Kinds.ExpressionKind;
    }): namedTypes.OptionalMemberExpression;
}

/** @public */
declare type OptionalMemberExpressionKind = namedTypes.OptionalMemberExpression;

declare class OrType<T> extends BaseType<T> {
    readonly types: Type<any>[];
    readonly kind: "OrType";
    constructor(types: Type<any>[]);
    toString(): string;
    check(value: any, deep?: Deep): value is T;
}

/** @public */
declare interface ParenthesizedExpressionBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.ParenthesizedExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ParenthesizedExpression;
}

/** @public */
declare type ParenthesizedExpressionKind = namedTypes.ParenthesizedExpression;

declare interface Path<V = any> {
    value: V;
    parentPath: any;
    name: any;
    __childCache: object | null;
    getValueProperty(name: any): any;
    get(...names: any[]): any;
    each(callback: any, context?: any): any;
    map(callback: any, context?: any): any;
    filter(callback: any, context?: any): any;
    shift(): any;
    unshift(...args: any[]): any;
    push(...args: any[]): any;
    pop(): any;
    insertAt(index: number, ...args: any[]): any;
    insertBefore(...args: any[]): any;
    insertAfter(...args: any[]): any;
    replace(replacement?: ASTNode, ...args: ASTNode[]): any;
}

declare interface PathVisitor {
    _reusableContextStack: any;
    _methodNameTable: any;
    _shouldVisitComments: any;
    Context: any;
    _visiting: any;
    _changeReported: any;
    _abortRequested: boolean;
    visit(...args: any[]): any;
    reset(...args: any[]): any;
    visitWithoutReset(path: any): any;
    AbortRequest: any;
    abort(): void;
    visitor: any;
    acquireContext(path: any): any;
    releaseContext(context: any): void;
    reportChanged(): void;
    wasChangeReported(): any;
}

/** @public */
declare type PatternKind = namedTypes.Identifier | namedTypes.RestElement | namedTypes.SpreadElementPattern | namedTypes.PropertyPattern | namedTypes.ObjectPattern | namedTypes.ArrayPattern | namedTypes.AssignmentPattern | namedTypes.SpreadPropertyPattern | namedTypes.PrivateIdentifier | namedTypes.PrivateName | namedTypes.JSXIdentifier | namedTypes.TSAsExpression | namedTypes.TSSatisfiesExpression | namedTypes.TSNonNullExpression | namedTypes.TSTypeParameter | namedTypes.TSTypeAssertion | namedTypes.TSParameterProperty;

/**
 * Union of plugin types
 * @public
 */
declare type Plugin_2 = ManualMigrationPlugin | CodemodPlugin;
export { Plugin_2 as Plugin }

/** @public */
declare type PositionKind = namedTypes.Position;

export { postcss }

declare class PredicateType<T> extends BaseType<T> {
    readonly name: string;
    readonly predicate: (value: any, deep?: Deep) => boolean;
    readonly kind: "PredicateType";
    constructor(name: string, predicate: (value: any, deep?: Deep) => boolean);
    toString(): string;
    check(value: any, deep?: Deep): value is T;
}

/** @public */
declare type PrintableKind = namedTypes.File | namedTypes.Program | namedTypes.Identifier | namedTypes.BlockStatement | namedTypes.EmptyStatement | namedTypes.ExpressionStatement | namedTypes.IfStatement | namedTypes.LabeledStatement | namedTypes.BreakStatement | namedTypes.ContinueStatement | namedTypes.WithStatement | namedTypes.SwitchStatement | namedTypes.SwitchCase | namedTypes.ReturnStatement | namedTypes.ThrowStatement | namedTypes.TryStatement | namedTypes.CatchClause | namedTypes.WhileStatement | namedTypes.DoWhileStatement | namedTypes.ForStatement | namedTypes.VariableDeclaration | namedTypes.ForInStatement | namedTypes.DebuggerStatement | namedTypes.FunctionDeclaration | namedTypes.FunctionExpression | namedTypes.VariableDeclarator | namedTypes.ThisExpression | namedTypes.ArrayExpression | namedTypes.ObjectExpression | namedTypes.Property | namedTypes.Literal | namedTypes.SequenceExpression | namedTypes.UnaryExpression | namedTypes.BinaryExpression | namedTypes.AssignmentExpression | namedTypes.MemberExpression | namedTypes.UpdateExpression | namedTypes.LogicalExpression | namedTypes.ConditionalExpression | namedTypes.NewExpression | namedTypes.CallExpression | namedTypes.RestElement | namedTypes.TypeAnnotation | namedTypes.TSTypeAnnotation | namedTypes.SpreadElementPattern | namedTypes.ArrowFunctionExpression | namedTypes.ForOfStatement | namedTypes.YieldExpression | namedTypes.GeneratorExpression | namedTypes.ComprehensionBlock | namedTypes.ComprehensionExpression | namedTypes.ObjectProperty | namedTypes.PropertyPattern | namedTypes.ObjectPattern | namedTypes.ArrayPattern | namedTypes.SpreadElement | namedTypes.AssignmentPattern | namedTypes.MethodDefinition | namedTypes.ClassPropertyDefinition | namedTypes.ClassProperty | namedTypes.StaticBlock | namedTypes.ClassBody | namedTypes.ClassDeclaration | namedTypes.ClassExpression | namedTypes.Super | namedTypes.ImportSpecifier | namedTypes.ImportDefaultSpecifier | namedTypes.ImportNamespaceSpecifier | namedTypes.ImportDeclaration | namedTypes.ExportNamedDeclaration | namedTypes.ExportSpecifier | namedTypes.ExportDefaultDeclaration | namedTypes.ExportAllDeclaration | namedTypes.TaggedTemplateExpression | namedTypes.TemplateLiteral | namedTypes.TemplateElement | namedTypes.MetaProperty | namedTypes.AwaitExpression | namedTypes.SpreadProperty | namedTypes.SpreadPropertyPattern | namedTypes.ImportExpression | namedTypes.ChainExpression | namedTypes.OptionalCallExpression | namedTypes.OptionalMemberExpression | namedTypes.PrivateIdentifier | namedTypes.Decorator | namedTypes.PrivateName | namedTypes.ClassPrivateProperty | namedTypes.ImportAttribute | namedTypes.RecordExpression | namedTypes.ObjectMethod | namedTypes.TupleExpression | namedTypes.ModuleExpression | namedTypes.JSXAttribute | namedTypes.JSXIdentifier | namedTypes.JSXNamespacedName | namedTypes.JSXExpressionContainer | namedTypes.JSXElement | namedTypes.JSXFragment | namedTypes.JSXMemberExpression | namedTypes.JSXSpreadAttribute | namedTypes.JSXEmptyExpression | namedTypes.JSXText | namedTypes.JSXSpreadChild | namedTypes.JSXOpeningElement | namedTypes.JSXClosingElement | namedTypes.JSXOpeningFragment | namedTypes.JSXClosingFragment | namedTypes.TypeParameterDeclaration | namedTypes.TSTypeParameterDeclaration | namedTypes.TypeParameterInstantiation | namedTypes.TSTypeParameterInstantiation | namedTypes.ClassImplements | namedTypes.TSExpressionWithTypeArguments | namedTypes.AnyTypeAnnotation | namedTypes.EmptyTypeAnnotation | namedTypes.MixedTypeAnnotation | namedTypes.VoidTypeAnnotation | namedTypes.SymbolTypeAnnotation | namedTypes.NumberTypeAnnotation | namedTypes.BigIntTypeAnnotation | namedTypes.NumberLiteralTypeAnnotation | namedTypes.NumericLiteralTypeAnnotation | namedTypes.BigIntLiteralTypeAnnotation | namedTypes.StringTypeAnnotation | namedTypes.StringLiteralTypeAnnotation | namedTypes.BooleanTypeAnnotation | namedTypes.BooleanLiteralTypeAnnotation | namedTypes.NullableTypeAnnotation | namedTypes.NullLiteralTypeAnnotation | namedTypes.NullTypeAnnotation | namedTypes.ThisTypeAnnotation | namedTypes.ExistsTypeAnnotation | namedTypes.ExistentialTypeParam | namedTypes.FunctionTypeAnnotation | namedTypes.FunctionTypeParam | namedTypes.ArrayTypeAnnotation | namedTypes.ObjectTypeAnnotation | namedTypes.ObjectTypeProperty | namedTypes.ObjectTypeSpreadProperty | namedTypes.ObjectTypeIndexer | namedTypes.ObjectTypeCallProperty | namedTypes.ObjectTypeInternalSlot | namedTypes.Variance | namedTypes.QualifiedTypeIdentifier | namedTypes.GenericTypeAnnotation | namedTypes.MemberTypeAnnotation | namedTypes.IndexedAccessType | namedTypes.OptionalIndexedAccessType | namedTypes.UnionTypeAnnotation | namedTypes.IntersectionTypeAnnotation | namedTypes.TypeofTypeAnnotation | namedTypes.TypeParameter | namedTypes.PropertyDefinition | namedTypes.InterfaceTypeAnnotation | namedTypes.InterfaceExtends | namedTypes.InterfaceDeclaration | namedTypes.DeclareInterface | namedTypes.TypeAlias | namedTypes.DeclareTypeAlias | namedTypes.OpaqueType | namedTypes.DeclareOpaqueType | namedTypes.TypeCastExpression | namedTypes.TupleTypeAnnotation | namedTypes.DeclareVariable | namedTypes.DeclareFunction | namedTypes.DeclareClass | namedTypes.DeclareModule | namedTypes.DeclareModuleExports | namedTypes.DeclareExportDeclaration | namedTypes.ExportBatchSpecifier | namedTypes.DeclareExportAllDeclaration | namedTypes.InferredPredicate | namedTypes.DeclaredPredicate | namedTypes.EnumDeclaration | namedTypes.ExportDeclaration | namedTypes.Block | namedTypes.Line | namedTypes.Noop | namedTypes.DoExpression | namedTypes.BindExpression | namedTypes.ParenthesizedExpression | namedTypes.ExportNamespaceSpecifier | namedTypes.ExportDefaultSpecifier | namedTypes.CommentBlock | namedTypes.CommentLine | namedTypes.Directive | namedTypes.DirectiveLiteral | namedTypes.InterpreterDirective | namedTypes.StringLiteral | namedTypes.NumericLiteral | namedTypes.BigIntLiteral | namedTypes.DecimalLiteral | namedTypes.NullLiteral | namedTypes.BooleanLiteral | namedTypes.RegExpLiteral | namedTypes.ClassMethod | namedTypes.ClassPrivateMethod | namedTypes.ClassAccessorProperty | namedTypes.RestProperty | namedTypes.ForAwaitStatement | namedTypes.Import | namedTypes.V8IntrinsicIdentifier | namedTypes.TopicReference | namedTypes.TSQualifiedName | namedTypes.TSTypeReference | namedTypes.TSAsExpression | namedTypes.TSTypeCastExpression | namedTypes.TSSatisfiesExpression | namedTypes.TSNonNullExpression | namedTypes.TSAnyKeyword | namedTypes.TSBigIntKeyword | namedTypes.TSBooleanKeyword | namedTypes.TSNeverKeyword | namedTypes.TSNullKeyword | namedTypes.TSNumberKeyword | namedTypes.TSObjectKeyword | namedTypes.TSStringKeyword | namedTypes.TSSymbolKeyword | namedTypes.TSUndefinedKeyword | namedTypes.TSUnknownKeyword | namedTypes.TSVoidKeyword | namedTypes.TSIntrinsicKeyword | namedTypes.TSThisType | namedTypes.TSArrayType | namedTypes.TSLiteralType | namedTypes.TSUnionType | namedTypes.TSIntersectionType | namedTypes.TSConditionalType | namedTypes.TSInferType | namedTypes.TSTypeParameter | namedTypes.TSParenthesizedType | namedTypes.TSFunctionType | namedTypes.TSConstructorType | namedTypes.TSDeclareFunction | namedTypes.TSDeclareMethod | namedTypes.TSMappedType | namedTypes.TSTupleType | namedTypes.TSNamedTupleMember | namedTypes.TSRestType | namedTypes.TSOptionalType | namedTypes.TSIndexedAccessType | namedTypes.TSTypeOperator | namedTypes.TSIndexSignature | namedTypes.TSPropertySignature | namedTypes.TSMethodSignature | namedTypes.TSTypePredicate | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration | namedTypes.TSEnumMember | namedTypes.TSTypeQuery | namedTypes.TSImportType | namedTypes.TSTypeLiteral | namedTypes.TSTypeAssertion | namedTypes.TSInstantiationExpression | namedTypes.TSEnumDeclaration | namedTypes.TSTypeAliasDeclaration | namedTypes.TSModuleBlock | namedTypes.TSModuleDeclaration | namedTypes.TSImportEqualsDeclaration | namedTypes.TSExternalModuleReference | namedTypes.TSExportAssignment | namedTypes.TSNamespaceExportDeclaration | namedTypes.TSInterfaceBody | namedTypes.TSInterfaceDeclaration | namedTypes.TSParameterProperty | namedTypes.TSEnumBody | namedTypes.TSInterfaceHeritage | namedTypes.TSClassImplements | namedTypes.TSTemplateLiteralType | namedTypes.TSEmptyBodyFunctionExpression | namedTypes.TSAbstractMethodDefinition | namedTypes.TSAbstractPropertyDefinition;

/** @public */
declare interface PrivateIdentifierBuilder {
    (id: Kinds.IdentifierKind): namedTypes.PrivateIdentifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        name?: string | undefined;
    }): namedTypes.PrivateIdentifier;
}

/** @public */
declare type PrivateIdentifierKind = namedTypes.PrivateIdentifier;

/** @public */
declare interface PrivateNameBuilder {
    (id: Kinds.IdentifierKind): namedTypes.PrivateName;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.PrivateName;
}

/** @public */
declare type PrivateNameKind = namedTypes.PrivateName;

/** @public */
declare interface ProgramBuilder {
    (body: Kinds.StatementKind[]): namedTypes.Program;
    from(params: {
        body: Kinds.StatementKind[];
        comments?: Kinds.CommentKind[] | null;
        directives?: Kinds.DirectiveKind[];
        interpreter?: Kinds.InterpreterDirectiveKind | null;
        loc?: Kinds.SourceLocationKind | null;
        sourceType?: "script" | "module";
    }): namedTypes.Program;
}

/** @public */
declare type ProgramKind = namedTypes.Program;

/**
 * Function signature for the onProgress function passed to createVueMetamorphCli
 * @public
 */
export declare type ProgressCallback = (args: {
    /**
     * Total number files matching the glob input
     */
    totalFiles: number;
    /**
     * Number of files that have already been processed
     */
    filesProcessed: number;
    /**
     * Number of files left to be processed
     */
    filesRemaining: number;
    /**
     * Number of changes each plugin has applied or reported
     */
    stats: Record<string, number>;
    /**
     * True if the runner was aborted before completing
     */
    aborted: boolean;
    /**
     * True if the runner finished processing all files
     */
    done: boolean;
    /**
     * Errors encountered during processing
     */
    errors: ErrorReport[];
    /**
     * Manual migrations reported by manual migration plugins
     */
    manualMigrations: ManualMigrationReport[];
}) => void;

/** @public */
declare interface PropertyBuilder {
    (kind: "init" | "get" | "set", key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, value: Kinds.ExpressionKind | Kinds.PatternKind): namedTypes.Property;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        kind: "init" | "get" | "set";
        loc?: Kinds.SourceLocationKind | null;
        method?: boolean;
        optional?: boolean;
        shorthand?: boolean;
        value: Kinds.ExpressionKind | Kinds.PatternKind;
    }): namedTypes.Property;
}

/** @public */
declare interface PropertyDefinitionBuilder {
    (): namedTypes.PropertyDefinition;
    from(params: {
        access?: "public" | "private" | "protected" | undefined;
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        declare?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
        static?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        value: Kinds.ExpressionKind | null;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.PropertyDefinition;
}

/** @public */
declare type PropertyDefinitionKind = namedTypes.PropertyDefinition | namedTypes.TSAbstractPropertyDefinition;

/** @public */
declare type PropertyKind = namedTypes.Property;

/** @public */
declare interface PropertyPatternBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, pattern: Kinds.PatternKind): namedTypes.PropertyPattern;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        pattern: Kinds.PatternKind;
    }): namedTypes.PropertyPattern;
}

/** @public */
declare type PropertyPatternKind = namedTypes.PropertyPattern;

/** @public */
declare interface QualifiedTypeIdentifierBuilder {
    (qualification: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind, id: Kinds.IdentifierKind): namedTypes.QualifiedTypeIdentifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        qualification: Kinds.IdentifierKind | Kinds.QualifiedTypeIdentifierKind;
    }): namedTypes.QualifiedTypeIdentifier;
}

/** @public */
declare type QualifiedTypeIdentifierKind = namedTypes.QualifiedTypeIdentifier;

/** @public */
declare interface RecordExpressionBuilder {
    (properties: (Kinds.ObjectPropertyKind | Kinds.ObjectMethodKind | Kinds.SpreadElementKind)[]): namedTypes.RecordExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        properties: (Kinds.ObjectPropertyKind | Kinds.ObjectMethodKind | Kinds.SpreadElementKind)[];
    }): namedTypes.RecordExpression;
}

/** @public */
declare type RecordExpressionKind = namedTypes.RecordExpression;

/** @public */
declare interface RegExpLiteralBuilder {
    (pattern: string, flags: string): namedTypes.RegExpLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        extra?: {
            rawValue: RegExp | undefined;
            raw: string;
        };
        flags: string;
        loc?: Kinds.SourceLocationKind | null;
        pattern: string;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        };
        value?: RegExp;
    }): namedTypes.RegExpLiteral;
}

/** @public */
declare type RegExpLiteralKind = namedTypes.RegExpLiteral;

declare type ReportFunction = (node: AST.Node | postcss.AnyNode, message: string) => void;

/** @public */
declare interface RestElementBuilder {
    (argument: Kinds.PatternKind): namedTypes.RestElement;
    from(params: {
        argument: Kinds.PatternKind;
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        value?: Kinds.ExpressionKind | null;
    }): namedTypes.RestElement;
}

/** @public */
declare type RestElementKind = namedTypes.RestElement;

/** @public */
declare interface RestPropertyBuilder {
    (argument: Kinds.ExpressionKind): namedTypes.RestProperty;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.RestProperty;
}

/** @public */
declare type RestPropertyKind = namedTypes.RestProperty;

/** @public */
declare interface ReturnStatementBuilder {
    (argument: Kinds.ExpressionKind | null): namedTypes.ReturnStatement;
    from(params: {
        argument: Kinds.ExpressionKind | null;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ReturnStatement;
}

/** @public */
declare type ReturnStatementKind = namedTypes.ReturnStatement;

declare interface Scope {
    type: ScopeType;
    path: NodePath;
    node: NodePath['value'];
    isGlobal: boolean;
    depth: number;
    parent: Scope | null;
    bindings: ScopeBinding;
    types: ScopeTypes;
    didScan: boolean;
    declares(name: string): boolean;
    declaresType(name: string): boolean;
    markAsStale(): void;
    scan(force?: boolean): void;
    getBindings(): ScopeBinding;
    getTypes(): ScopeTypes;
    lookup(name: string): Scope;
    lookupType(name: string): Scope;
    getGlobalScope(): Scope | null;
    scanScope: (path: NodePath, bindings: ScopeBinding, scopeTypes: ScopeTypes) => void;
    recursiveScanScope: (path: NodePath, bindings: ScopeBinding, scopeTypes: ScopeTypes) => void;
    recursiveScanChild: (path: NodePath, bindings: ScopeBinding, scopeTypes: ScopeTypes) => void;
}

declare type ScopeBinding = Record<string, NodePath<namedTypes.Identifier>[]>;

declare type ScopeType = "global" | "function" | "block" | "switch" | "catch" | "with" | "for" | "class" | "type";

declare type ScopeTypes = Record<string, NodePath[]>;

/** @public */
declare interface SequenceExpressionBuilder {
    (expressions: Kinds.ExpressionKind[]): namedTypes.SequenceExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expressions: Kinds.ExpressionKind[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SequenceExpression;
}

/** @public */
declare type SequenceExpressionKind = namedTypes.SequenceExpression;

declare interface SharedContextMethods {
    currentPath: any;
    needToCallTraverse: boolean;
    Context: any;
    visitor: any;
    reset(path: any, ...args: any[]): any;
    invokeVisitorMethod(methodName: string): any;
    traverse(path: any, newVisitor?: VisitorMethods): any;
    visit(path: any, newVisitor?: VisitorMethods): any;
    reportChanged(): void;
    abort(): void;
}

/** @public */
declare type SourceLocationKind = namedTypes.SourceLocation;

/** @public */
declare type SpecifierKind = namedTypes.ImportSpecifier | namedTypes.ImportDefaultSpecifier | namedTypes.ImportNamespaceSpecifier | namedTypes.ExportSpecifier | namedTypes.ExportBatchSpecifier | namedTypes.ExportNamespaceSpecifier | namedTypes.ExportDefaultSpecifier;

/** @public */
declare interface SpreadElementBuilder {
    (argument: Kinds.ExpressionKind): namedTypes.SpreadElement;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SpreadElement;
}

/** @public */
declare type SpreadElementKind = namedTypes.SpreadElement;

/** @public */
declare interface SpreadElementPatternBuilder {
    (argument: Kinds.PatternKind): namedTypes.SpreadElementPattern;
    from(params: {
        argument: Kinds.PatternKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SpreadElementPattern;
}

/** @public */
declare type SpreadElementPatternKind = namedTypes.SpreadElementPattern;

/** @public */
declare interface SpreadPropertyBuilder {
    (argument: Kinds.ExpressionKind): namedTypes.SpreadProperty;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SpreadProperty;
}

/** @public */
declare type SpreadPropertyKind = namedTypes.SpreadProperty;

/** @public */
declare interface SpreadPropertyPatternBuilder {
    (argument: Kinds.PatternKind): namedTypes.SpreadPropertyPattern;
    from(params: {
        argument: Kinds.PatternKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SpreadPropertyPattern;
}

/** @public */
declare type SpreadPropertyPatternKind = namedTypes.SpreadPropertyPattern;

/** @public */
declare type StatementKind = namedTypes.BlockStatement | namedTypes.EmptyStatement | namedTypes.ExpressionStatement | namedTypes.IfStatement | namedTypes.LabeledStatement | namedTypes.BreakStatement | namedTypes.ContinueStatement | namedTypes.WithStatement | namedTypes.SwitchStatement | namedTypes.ReturnStatement | namedTypes.ThrowStatement | namedTypes.TryStatement | namedTypes.WhileStatement | namedTypes.DoWhileStatement | namedTypes.ForStatement | namedTypes.VariableDeclaration | namedTypes.ForInStatement | namedTypes.DebuggerStatement | namedTypes.FunctionDeclaration | namedTypes.ForOfStatement | namedTypes.MethodDefinition | namedTypes.ClassPropertyDefinition | namedTypes.ClassProperty | namedTypes.StaticBlock | namedTypes.ClassBody | namedTypes.ClassDeclaration | namedTypes.ImportDeclaration | namedTypes.ExportNamedDeclaration | namedTypes.ExportDefaultDeclaration | namedTypes.ExportAllDeclaration | namedTypes.ClassPrivateProperty | namedTypes.TSTypeParameterDeclaration | namedTypes.PropertyDefinition | namedTypes.InterfaceDeclaration | namedTypes.DeclareInterface | namedTypes.TypeAlias | namedTypes.DeclareTypeAlias | namedTypes.OpaqueType | namedTypes.DeclareOpaqueType | namedTypes.DeclareVariable | namedTypes.DeclareFunction | namedTypes.DeclareClass | namedTypes.DeclareModule | namedTypes.DeclareModuleExports | namedTypes.DeclareExportDeclaration | namedTypes.DeclareExportAllDeclaration | namedTypes.EnumDeclaration | namedTypes.ExportDeclaration | namedTypes.Noop | namedTypes.ClassMethod | namedTypes.ClassPrivateMethod | namedTypes.ClassAccessorProperty | namedTypes.ForAwaitStatement | namedTypes.TSDeclareFunction | namedTypes.TSDeclareMethod | namedTypes.TSIndexSignature | namedTypes.TSPropertySignature | namedTypes.TSMethodSignature | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration | namedTypes.TSEnumDeclaration | namedTypes.TSTypeAliasDeclaration | namedTypes.TSModuleDeclaration | namedTypes.TSImportEqualsDeclaration | namedTypes.TSExternalModuleReference | namedTypes.TSExportAssignment | namedTypes.TSNamespaceExportDeclaration | namedTypes.TSInterfaceDeclaration | namedTypes.TSAbstractMethodDefinition | namedTypes.TSAbstractPropertyDefinition;

/** @public */
declare interface StaticBlockBuilder {
    (body: Kinds.StatementKind[]): namedTypes.StaticBlock;
    from(params: {
        body: Kinds.StatementKind[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.StaticBlock;
}

/** @public */
declare type StaticBlockKind = namedTypes.StaticBlock;

/** @public */
declare interface StringLiteralBuilder {
    (value: string): namedTypes.StringLiteral;
    from(params: {
        bigint?: string | undefined;
        comments?: Kinds.CommentKind[] | null;
        extra?: {
            rawValue: string;
            raw: string;
        };
        loc?: Kinds.SourceLocationKind | null;
        raw?: string | null | undefined;
        regex?: {
            pattern: string;
            flags: string;
        } | undefined;
        value: string;
    }): namedTypes.StringLiteral;
}

/** @public */
declare type StringLiteralKind = namedTypes.StringLiteral;

/** @public */
declare interface StringLiteralTypeAnnotationBuilder {
    (value: string, raw: string): namedTypes.StringLiteralTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        raw: string;
        value: string;
    }): namedTypes.StringLiteralTypeAnnotation;
}

/** @public */
declare type StringLiteralTypeAnnotationKind = namedTypes.StringLiteralTypeAnnotation;

/** @public */
declare interface StringTypeAnnotationBuilder {
    (): namedTypes.StringTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.StringTypeAnnotation;
}

/** @public */
declare type StringTypeAnnotationKind = namedTypes.StringTypeAnnotation;

/** @public */
declare interface SuperBuilder {
    (): namedTypes.Super;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.Super;
}

/** @public */
declare type SuperKind = namedTypes.Super;

/** @public */
declare interface SwitchCaseBuilder {
    (test: Kinds.ExpressionKind | null, consequent: Kinds.StatementKind[]): namedTypes.SwitchCase;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        consequent: Kinds.StatementKind[];
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind | null;
    }): namedTypes.SwitchCase;
}

/** @public */
declare type SwitchCaseKind = namedTypes.SwitchCase;

/** @public */
declare interface SwitchStatementBuilder {
    (discriminant: Kinds.ExpressionKind, cases: Kinds.SwitchCaseKind[], lexical?: boolean): namedTypes.SwitchStatement;
    from(params: {
        cases: Kinds.SwitchCaseKind[];
        comments?: Kinds.CommentKind[] | null;
        discriminant: Kinds.ExpressionKind;
        lexical?: boolean;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SwitchStatement;
}

/** @public */
declare type SwitchStatementKind = namedTypes.SwitchStatement;

/** @public */
declare interface SymbolTypeAnnotationBuilder {
    (): namedTypes.SymbolTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.SymbolTypeAnnotation;
}

/** @public */
declare type SymbolTypeAnnotationKind = namedTypes.SymbolTypeAnnotation;

/** @public */
declare interface TaggedTemplateExpressionBuilder {
    (tag: Kinds.ExpressionKind, quasi: Kinds.TemplateLiteralKind): namedTypes.TaggedTemplateExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        quasi: Kinds.TemplateLiteralKind;
        tag: Kinds.ExpressionKind;
    }): namedTypes.TaggedTemplateExpression;
}

/** @public */
declare type TaggedTemplateExpressionKind = namedTypes.TaggedTemplateExpression;

/**
 * @public
 */
declare const TEMPLATE_NODE_TYPES: ReadonlySet<string>;

/** @public */
declare interface TemplateElementBuilder {
    (value: {
        cooked: string | null;
        raw: string;
    }, tail: boolean): namedTypes.TemplateElement;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        tail: boolean;
        value: {
            cooked: string | null;
            raw: string;
        };
    }): namedTypes.TemplateElement;
}

/** @public */
declare type TemplateElementKind = namedTypes.TemplateElement;

/** @public */
declare interface TemplateLiteralBuilder {
    (quasis: Kinds.TemplateElementKind[], expressions: Kinds.ExpressionKind[] | Kinds.TSTypeKind[]): namedTypes.TemplateLiteral;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expressions: Kinds.ExpressionKind[] | Kinds.TSTypeKind[];
        loc?: Kinds.SourceLocationKind | null;
        quasis: Kinds.TemplateElementKind[];
    }): namedTypes.TemplateLiteral;
}

/** @public */
declare type TemplateLiteralKind = namedTypes.TemplateLiteral;

/** @public */
declare interface ThisExpressionBuilder {
    (): namedTypes.ThisExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ThisExpression;
}

/** @public */
declare type ThisExpressionKind = namedTypes.ThisExpression;

/** @public */
declare interface ThisTypeAnnotationBuilder {
    (): namedTypes.ThisTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ThisTypeAnnotation;
}

/** @public */
declare type ThisTypeAnnotationKind = namedTypes.ThisTypeAnnotation;

/** @public */
declare interface ThrowStatementBuilder {
    (argument: Kinds.ExpressionKind): namedTypes.ThrowStatement;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.ThrowStatement;
}

/** @public */
declare type ThrowStatementKind = namedTypes.ThrowStatement;

/** @public */
declare interface TopicReferenceBuilder {
    (): namedTypes.TopicReference;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TopicReference;
}

/** @public */
declare type TopicReferenceKind = namedTypes.TopicReference;

/**
 * Parses source code into ASTs, runs codemod plugins against them, and returns
 * the transformed source code. This is the core function of vue-metamorph.
 *
 * The filename determines how code is parsed:
 * - `.vue` — Parsed as a Vue SFC (template + scripts + styles)
 * - `.js`, `.jsx`, `.ts`, `.tsx` — Parsed as JavaScript/TypeScript
 * - `.css`, `.scss`, `.sass`, `.less`, `.styl` — Parsed as CSS
 *
 * @example
 * ```ts
 * import { transform, type CodemodPlugin } from 'vue-metamorph';
 *
 * const myPlugin: CodemodPlugin = {
 *   type: 'codemod',
 *   name: 'my-transform',
 *   transform({ scriptASTs, utils: { traverseScriptAST } }) {
 *     let count = 0;
 *     for (const ast of scriptASTs) {
 *       traverseScriptAST(ast, {
 *         visitLiteral(path) {
 *           if (typeof path.node.value === 'string') {
 *             path.node.value = 'Hello, world!';
 *             count++;
 *           }
 *           return this.traverse(path);
 *         },
 *       });
 *     }
 *     return count;
 *   },
 * };
 *
 * const result = transform(sourceCode, 'file.vue', [myPlugin]);
 * result.code;  // transformed source code
 * result.stats; // [['my-transform', 3]]
 * ```
 *
 * @param code - Source code string
 * @param filename - The file name (determines parser selection)
 * @param plugins - List of codemod plugins to run
 * @param opts - Additional options passed through to plugins
 * @returns Object with `code` (transformed source) and `stats` (per-plugin transform counts)
 * @public
 */
export declare function transform(code: string, filename: string, plugins: CodemodPlugin[], opts?: Record<string, any>): TransformResult;

/**
 * Return type of the `transform` function, containing new source code and codemod stats
 * @public
 */
export declare type TransformResult = {
    /**
     * The new source code
     */
    code: string;
    /**
     * Stats on how many transforms each codemod reported that it made
     */
    stats: [codemodName: string, transformCount: number][];
};

/**
 * @public
 */
declare const traverseNodes: (node: Node_2, visitor: {
    enterNode?(node: Node_2, parent: Node_2 | null): void;
    leaveNode?(node: Node_2, parent: Node_2 | null): void;
}) => void;

/**
 * Traverse a script AST, an alias for ast-types' `visit`.
 *
 * Declared here rather than re-exported directly so it carries a release tag;
 * api-extractor cannot attach one to a destructured binding inside the
 * vendored module.
 *
 * @public
 */
export declare const traverseScriptAST: <M = {}>(node: ASTNode, methods?: Visitor<M>) => any;

/** @public */
declare interface TryStatementBuilder {
    (block: Kinds.BlockStatementKind, handler?: Kinds.CatchClauseKind | null, finalizer?: Kinds.BlockStatementKind | null): namedTypes.TryStatement;
    from(params: {
        block: Kinds.BlockStatementKind;
        comments?: Kinds.CommentKind[] | null;
        finalizer?: Kinds.BlockStatementKind | null;
        guardedHandlers?: Kinds.CatchClauseKind[];
        handler?: Kinds.CatchClauseKind | null;
        handlers?: Kinds.CatchClauseKind[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TryStatement;
}

/** @public */
declare type TryStatementKind = namedTypes.TryStatement;

/** @public */
declare interface TSAbstractMethodDefinitionBuilder {
    (key: Kinds.ExpressionKind, value: Kinds.TSEmptyBodyFunctionExpressionKind | Kinds.FunctionExpressionKind, kind: "constructor" | "method" | "get" | "set", staticParam?: boolean): namedTypes.TSAbstractMethodDefinition;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        key: Kinds.ExpressionKind;
        kind: "constructor" | "method" | "get" | "set";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        static?: boolean;
        value: Kinds.TSEmptyBodyFunctionExpressionKind | Kinds.FunctionExpressionKind;
    }): namedTypes.TSAbstractMethodDefinition;
}

/** @public */
declare type TSAbstractMethodDefinitionKind = namedTypes.TSAbstractMethodDefinition;

/** @public */
declare interface TSAbstractPropertyDefinitionBuilder {
    (key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind, value?: Kinds.ExpressionKind | null): namedTypes.TSAbstractPropertyDefinition;
    from(params: {
        access?: "public" | "private" | "protected" | undefined;
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        declare?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        definite?: boolean;
        key: Kinds.LiteralKind | Kinds.IdentifierKind | Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        override?: boolean;
        readonly?: boolean;
        static?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
        value?: Kinds.ExpressionKind | null;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.TSAbstractPropertyDefinition;
}

/** @public */
declare type TSAbstractPropertyDefinitionKind = namedTypes.TSAbstractPropertyDefinition;

/** @public */
declare interface TSAnyKeywordBuilder {
    (): namedTypes.TSAnyKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSAnyKeyword;
}

/** @public */
declare type TSAnyKeywordKind = namedTypes.TSAnyKeyword;

/** @public */
declare interface TSArrayTypeBuilder {
    (elementType: Kinds.TSTypeKind): namedTypes.TSArrayType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elementType: Kinds.TSTypeKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSArrayType;
}

/** @public */
declare type TSArrayTypeKind = namedTypes.TSArrayType;

/** @public */
declare interface TSAsExpressionBuilder {
    (expression: Kinds.ExpressionKind, typeAnnotation: Kinds.TSTypeKind): namedTypes.TSAsExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        extra?: {
            parenthesized: boolean;
        } | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSAsExpression;
}

/** @public */
declare type TSAsExpressionKind = namedTypes.TSAsExpression;

/** @public */
declare interface TSBigIntKeywordBuilder {
    (): namedTypes.TSBigIntKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSBigIntKeyword;
}

/** @public */
declare type TSBigIntKeywordKind = namedTypes.TSBigIntKeyword;

/** @public */
declare interface TSBooleanKeywordBuilder {
    (): namedTypes.TSBooleanKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSBooleanKeyword;
}

/** @public */
declare type TSBooleanKeywordKind = namedTypes.TSBooleanKeyword;

/** @public */
declare interface TSCallSignatureDeclarationBuilder {
    (parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[], typeAnnotation?: Kinds.TSTypeAnnotationKind | null): namedTypes.TSCallSignatureDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSCallSignatureDeclaration;
}

/** @public */
declare type TSCallSignatureDeclarationKind = namedTypes.TSCallSignatureDeclaration;

/** @public */
declare interface TSClassImplementsBuilder {
    (expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined): namedTypes.TSClassImplements;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        loc?: Kinds.SourceLocationKind | null;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }): namedTypes.TSClassImplements;
}

/** @public */
declare type TSClassImplementsKind = namedTypes.TSClassImplements;

/** @public */
declare interface TSConditionalTypeBuilder {
    (checkType: Kinds.TSTypeKind, extendsType: Kinds.TSTypeKind, trueType: Kinds.TSTypeKind, falseType: Kinds.TSTypeKind): namedTypes.TSConditionalType;
    from(params: {
        checkType: Kinds.TSTypeKind;
        comments?: Kinds.CommentKind[] | null;
        extendsType: Kinds.TSTypeKind;
        falseType: Kinds.TSTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        trueType: Kinds.TSTypeKind;
    }): namedTypes.TSConditionalType;
}

/** @public */
declare type TSConditionalTypeKind = namedTypes.TSConditionalType;

/** @public */
declare interface TSConstructorTypeBuilder {
    (parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[]): namedTypes.TSConstructorType;
    from(params: {
        abstract?: boolean;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSConstructorType;
}

/** @public */
declare type TSConstructorTypeKind = namedTypes.TSConstructorType;

/** @public */
declare interface TSConstructSignatureDeclarationBuilder {
    (parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[], typeAnnotation?: Kinds.TSTypeAnnotationKind | null): namedTypes.TSConstructSignatureDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSConstructSignatureDeclaration;
}

/** @public */
declare type TSConstructSignatureDeclarationKind = namedTypes.TSConstructSignatureDeclaration;

/** @public */
declare interface TSDeclareFunctionBuilder {
    (id: Kinds.IdentifierKind | null | undefined, params: Kinds.PatternKind[], returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null): namedTypes.TSDeclareFunction;
    from(params: {
        async?: boolean;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSDeclareFunction;
}

/** @public */
declare type TSDeclareFunctionKind = namedTypes.TSDeclareFunction;

/** @public */
declare interface TSDeclareMethodBuilder {
    (key: Kinds.IdentifierKind | Kinds.StringLiteralKind | Kinds.NumericLiteralKind | Kinds.ExpressionKind, params: Kinds.PatternKind[], returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null): namedTypes.TSDeclareMethod;
    from(params: {
        abstract?: boolean;
        access?: "public" | "private" | "protected" | undefined;
        accessibility?: "public" | "private" | "protected" | undefined;
        async?: boolean;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        decorators?: Kinds.DecoratorKind[] | null;
        generator?: boolean;
        key: Kinds.IdentifierKind | Kinds.StringLiteralKind | Kinds.NumericLiteralKind | Kinds.ExpressionKind;
        kind?: "get" | "set" | "method" | "constructor";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        params: Kinds.PatternKind[];
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null;
        static?: boolean;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSDeclareMethod;
}

/** @public */
declare type TSDeclareMethodKind = namedTypes.TSDeclareMethod;

/** @public */
declare interface TSEmptyBodyFunctionExpressionBuilder {
    (id: Kinds.IdentifierKind | null | undefined, params: Kinds.PatternKind[], returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined): namedTypes.TSEmptyBodyFunctionExpression;
    from(params: {
        async?: boolean;
        body?: null;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        defaults?: (Kinds.ExpressionKind | null)[];
        expression?: boolean;
        generator?: boolean;
        id?: Kinds.IdentifierKind | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.PatternKind[];
        predicate?: Kinds.FlowPredicateKind | null;
        rest?: Kinds.IdentifierKind | null;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        typeParameters?: Kinds.TypeParameterDeclarationKind | Kinds.TSTypeParameterDeclarationKind | null;
    }): namedTypes.TSEmptyBodyFunctionExpression;
}

/** @public */
declare type TSEmptyBodyFunctionExpressionKind = namedTypes.TSEmptyBodyFunctionExpression;

/** @public */
declare interface TSEnumBodyBuilder {
    (members: Kinds.TSEnumMemberKind[]): namedTypes.TSEnumBody;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        members: Kinds.TSEnumMemberKind[];
    }): namedTypes.TSEnumBody;
}

/** @public */
declare type TSEnumBodyKind = namedTypes.TSEnumBody;

/** @public */
declare interface TSEnumDeclarationBuilder {
    (id: Kinds.IdentifierKind, members: Kinds.TSEnumMemberKind[]): namedTypes.TSEnumDeclaration;
    from(params: {
        body?: Kinds.TSEnumBodyKind | undefined;
        comments?: Kinds.CommentKind[] | null;
        const?: boolean;
        declare?: boolean;
        id: Kinds.IdentifierKind;
        initializer?: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
        members: Kinds.TSEnumMemberKind[];
    }): namedTypes.TSEnumDeclaration;
}

/** @public */
declare type TSEnumDeclarationKind = namedTypes.TSEnumDeclaration;

/** @public */
declare interface TSEnumMemberBuilder {
    (id: Kinds.IdentifierKind | Kinds.StringLiteralKind, initializer?: Kinds.ExpressionKind | null): namedTypes.TSEnumMember;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        id: Kinds.IdentifierKind | Kinds.StringLiteralKind;
        initializer?: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSEnumMember;
}

/** @public */
declare type TSEnumMemberKind = namedTypes.TSEnumMember;

/** @public */
declare interface TSExportAssignmentBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.TSExportAssignment;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSExportAssignment;
}

/** @public */
declare type TSExportAssignmentKind = namedTypes.TSExportAssignment;

/** @public */
declare interface TSExpressionWithTypeArgumentsBuilder {
    (expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, typeParameters?: Kinds.TSTypeParameterInstantiationKind | null): namedTypes.TSExpressionWithTypeArguments;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.TSExpressionWithTypeArguments;
}

/** @public */
declare type TSExpressionWithTypeArgumentsKind = namedTypes.TSExpressionWithTypeArguments;

/** @public */
declare interface TSExternalModuleReferenceBuilder {
    (expression: Kinds.StringLiteralKind): namedTypes.TSExternalModuleReference;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.StringLiteralKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSExternalModuleReference;
}

/** @public */
declare type TSExternalModuleReferenceKind = namedTypes.TSExternalModuleReference;

/** @public */
declare interface TSFunctionTypeBuilder {
    (parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[]): namedTypes.TSFunctionType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSFunctionType;
}

/** @public */
declare type TSFunctionTypeKind = namedTypes.TSFunctionType;

/** @public */
declare type TSHasOptionalTypeAnnotationKind = namedTypes.ClassAccessorProperty | namedTypes.TSFunctionType | namedTypes.TSConstructorType | namedTypes.TSIndexSignature | namedTypes.TSPropertySignature | namedTypes.TSMethodSignature | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration;

/** @public */
declare type TSHasOptionalTypeParameterInstantiationKind = namedTypes.CallExpression | namedTypes.OptionalCallExpression | namedTypes.TSExpressionWithTypeArguments | namedTypes.TSTypeReference | namedTypes.TSImportType | namedTypes.TSInstantiationExpression;

/** @public */
declare type TSHasOptionalTypeParametersKind = namedTypes.TSFunctionType | namedTypes.TSConstructorType | namedTypes.TSDeclareFunction | namedTypes.TSDeclareMethod | namedTypes.TSMethodSignature | namedTypes.TSCallSignatureDeclaration | namedTypes.TSConstructSignatureDeclaration | namedTypes.TSTypeAliasDeclaration | namedTypes.TSInterfaceDeclaration;

/** @public */
declare interface TSImportEqualsDeclarationBuilder {
    (id: Kinds.IdentifierKind, moduleReference: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSExternalModuleReferenceKind): namedTypes.TSImportEqualsDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        importKind?: "type" | "value" | undefined;
        isExport?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        moduleReference: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSExternalModuleReferenceKind;
    }): namedTypes.TSImportEqualsDeclaration;
}

/** @public */
declare type TSImportEqualsDeclarationKind = namedTypes.TSImportEqualsDeclaration;

/** @public */
declare interface TSImportTypeBuilder {
    (argument: Kinds.StringLiteralKind, qualifier?: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | undefined, typeParameters?: Kinds.TSTypeParameterInstantiationKind | null): namedTypes.TSImportType;
    from(params: {
        argument: Kinds.StringLiteralKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        options?: Kinds.ExpressionKind | null | undefined;
        qualifier?: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | undefined;
        source?: Kinds.StringLiteralKind | undefined;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.TSImportType;
}

/** @public */
declare type TSImportTypeKind = namedTypes.TSImportType;

/** @public */
declare interface TSIndexedAccessTypeBuilder {
    (objectType: Kinds.TSTypeKind, indexType: Kinds.TSTypeKind): namedTypes.TSIndexedAccessType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        indexType: Kinds.TSTypeKind;
        loc?: Kinds.SourceLocationKind | null;
        objectType: Kinds.TSTypeKind;
    }): namedTypes.TSIndexedAccessType;
}

/** @public */
declare type TSIndexedAccessTypeKind = namedTypes.TSIndexedAccessType;

/** @public */
declare interface TSIndexSignatureBuilder {
    (parameters: Kinds.IdentifierKind[], typeAnnotation?: Kinds.TSTypeAnnotationKind | null): namedTypes.TSIndexSignature;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameters: Kinds.IdentifierKind[];
        readonly?: boolean;
        static?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.TSIndexSignature;
}

/** @public */
declare type TSIndexSignatureKind = namedTypes.TSIndexSignature;

/** @public */
declare interface TSInferTypeBuilder {
    (typeParameter: Kinds.TSTypeParameterKind): namedTypes.TSInferType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeParameter: Kinds.TSTypeParameterKind;
    }): namedTypes.TSInferType;
}

/** @public */
declare type TSInferTypeKind = namedTypes.TSInferType;

/** @public */
declare interface TSInstantiationExpressionBuilder {
    (expression: Kinds.ExpressionKind, typeParameters?: Kinds.TSTypeParameterInstantiationKind | null): namedTypes.TSInstantiationExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.TSInstantiationExpression;
}

/** @public */
declare type TSInstantiationExpressionKind = namedTypes.TSInstantiationExpression;

/** @public */
declare interface TSInterfaceBodyBuilder {
    (body: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[]): namedTypes.TSInterfaceBody;
    from(params: {
        body: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSInterfaceBody;
}

/** @public */
declare type TSInterfaceBodyKind = namedTypes.TSInterfaceBody;

/** @public */
declare interface TSInterfaceDeclarationBuilder {
    (id: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, body: Kinds.TSInterfaceBodyKind): namedTypes.TSInterfaceDeclaration;
    from(params: {
        body: Kinds.TSInterfaceBodyKind;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        extends?: (Kinds.TSInterfaceHeritageKind | Kinds.TSExpressionWithTypeArgumentsKind)[] | null;
        id: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        loc?: Kinds.SourceLocationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSInterfaceDeclaration;
}

/** @public */
declare type TSInterfaceDeclarationKind = namedTypes.TSInterfaceDeclaration;

/** @public */
declare interface TSInterfaceHeritageBuilder {
    (expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined): namedTypes.TSInterfaceHeritage;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        loc?: Kinds.SourceLocationKind | null;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
    }): namedTypes.TSInterfaceHeritage;
}

/** @public */
declare type TSInterfaceHeritageKind = namedTypes.TSInterfaceHeritage;

/** @public */
declare interface TSIntersectionTypeBuilder {
    (types: Kinds.TSTypeKind[]): namedTypes.TSIntersectionType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        types: Kinds.TSTypeKind[];
    }): namedTypes.TSIntersectionType;
}

/** @public */
declare type TSIntersectionTypeKind = namedTypes.TSIntersectionType;

/** @public */
declare interface TSIntrinsicKeywordBuilder {
    (): namedTypes.TSIntrinsicKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSIntrinsicKeyword;
}

/** @public */
declare type TSIntrinsicKeywordKind = namedTypes.TSIntrinsicKeyword;

/** @public */
declare interface TSLiteralTypeBuilder {
    (literal: Kinds.NumericLiteralKind | Kinds.StringLiteralKind | Kinds.BooleanLiteralKind | Kinds.TemplateLiteralKind | Kinds.UnaryExpressionKind | Kinds.BigIntLiteralKind): namedTypes.TSLiteralType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        literal: Kinds.NumericLiteralKind | Kinds.StringLiteralKind | Kinds.BooleanLiteralKind | Kinds.TemplateLiteralKind | Kinds.UnaryExpressionKind | Kinds.BigIntLiteralKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSLiteralType;
}

/** @public */
declare type TSLiteralTypeKind = namedTypes.TSLiteralType;

/** @public */
declare interface TSMappedTypeBuilder {
    (typeParameter: Kinds.TSTypeParameterKind, typeAnnotation?: Kinds.TSTypeKind | null): namedTypes.TSMappedType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        constraint?: Kinds.TSTypeKind | undefined;
        key?: Kinds.IdentifierKind | undefined;
        loc?: Kinds.SourceLocationKind | null;
        nameType?: Kinds.TSTypeKind | null;
        optional?: boolean | "+" | "-";
        readonly?: boolean | "+" | "-";
        typeAnnotation?: Kinds.TSTypeKind | null;
        typeParameter: Kinds.TSTypeParameterKind;
    }): namedTypes.TSMappedType;
}

/** @public */
declare type TSMappedTypeKind = namedTypes.TSMappedType;

/** @public */
declare interface TSMethodSignatureBuilder {
    (key: Kinds.ExpressionKind, parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[], typeAnnotation?: Kinds.TSTypeAnnotationKind | null): namedTypes.TSMethodSignature;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        key: Kinds.ExpressionKind;
        kind?: "method" | "get" | "set";
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        parameters: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind)[];
        params?: (Kinds.IdentifierKind | Kinds.RestElementKind | Kinds.ArrayPatternKind | Kinds.ObjectPatternKind | Kinds.TSParameterPropertyKind)[] | undefined;
        readonly?: boolean;
        returnType?: Kinds.TSTypeAnnotationKind | Kinds.NoopKind | null | undefined;
        static?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSMethodSignature;
}

/** @public */
declare type TSMethodSignatureKind = namedTypes.TSMethodSignature;

/** @public */
declare interface TSModuleBlockBuilder {
    (body: Kinds.StatementKind[]): namedTypes.TSModuleBlock;
    from(params: {
        body: Kinds.StatementKind[];
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSModuleBlock;
}

/** @public */
declare type TSModuleBlockKind = namedTypes.TSModuleBlock;

/** @public */
declare interface TSModuleDeclarationBuilder {
    (id: Kinds.StringLiteralKind | Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, body?: Kinds.TSModuleBlockKind | Kinds.TSModuleDeclarationKind | null): namedTypes.TSModuleDeclaration;
    from(params: {
        body?: Kinds.TSModuleBlockKind | Kinds.TSModuleDeclarationKind | null;
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        global?: boolean;
        id: Kinds.StringLiteralKind | Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        kind?: "global" | "module" | "namespace" | undefined;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSModuleDeclaration;
}

/** @public */
declare type TSModuleDeclarationKind = namedTypes.TSModuleDeclaration;

/** @public */
declare interface TSNamedTupleMemberBuilder {
    (label: Kinds.IdentifierKind, elementType: Kinds.TSTypeKind, optional?: boolean): namedTypes.TSNamedTupleMember;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elementType: Kinds.TSTypeKind;
        label: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
    }): namedTypes.TSNamedTupleMember;
}

/** @public */
declare type TSNamedTupleMemberKind = namedTypes.TSNamedTupleMember;

/** @public */
declare interface TSNamespaceExportDeclarationBuilder {
    (id: Kinds.IdentifierKind): namedTypes.TSNamespaceExportDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSNamespaceExportDeclaration;
}

/** @public */
declare type TSNamespaceExportDeclarationKind = namedTypes.TSNamespaceExportDeclaration;

/** @public */
declare interface TSNeverKeywordBuilder {
    (): namedTypes.TSNeverKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSNeverKeyword;
}

/** @public */
declare type TSNeverKeywordKind = namedTypes.TSNeverKeyword;

/** @public */
declare interface TSNonNullExpressionBuilder {
    (expression: Kinds.ExpressionKind): namedTypes.TSNonNullExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSNonNullExpression;
}

/** @public */
declare type TSNonNullExpressionKind = namedTypes.TSNonNullExpression;

/** @public */
declare interface TSNullKeywordBuilder {
    (): namedTypes.TSNullKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSNullKeyword;
}

/** @public */
declare type TSNullKeywordKind = namedTypes.TSNullKeyword;

/** @public */
declare interface TSNumberKeywordBuilder {
    (): namedTypes.TSNumberKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSNumberKeyword;
}

/** @public */
declare type TSNumberKeywordKind = namedTypes.TSNumberKeyword;

/** @public */
declare interface TSObjectKeywordBuilder {
    (): namedTypes.TSObjectKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSObjectKeyword;
}

/** @public */
declare type TSObjectKeywordKind = namedTypes.TSObjectKeyword;

/** @public */
declare interface TSOptionalTypeBuilder {
    (typeAnnotation: Kinds.TSTypeKind): namedTypes.TSOptionalType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSOptionalType;
}

/** @public */
declare type TSOptionalTypeKind = namedTypes.TSOptionalType;

/** @public */
declare interface TSParameterPropertyBuilder {
    (parameter: Kinds.IdentifierKind | Kinds.AssignmentPatternKind): namedTypes.TSParameterProperty;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        decorators?: Kinds.DecoratorKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        override?: boolean;
        parameter: Kinds.IdentifierKind | Kinds.AssignmentPatternKind;
        readonly?: boolean;
        static?: boolean;
    }): namedTypes.TSParameterProperty;
}

/** @public */
declare type TSParameterPropertyKind = namedTypes.TSParameterProperty;

/** @public */
declare interface TSParenthesizedTypeBuilder {
    (typeAnnotation: Kinds.TSTypeKind): namedTypes.TSParenthesizedType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSParenthesizedType;
}

/** @public */
declare type TSParenthesizedTypeKind = namedTypes.TSParenthesizedType;

/** @public */
declare interface TSPropertySignatureBuilder {
    (key: Kinds.ExpressionKind, typeAnnotation?: Kinds.TSTypeAnnotationKind | null, optional?: boolean): namedTypes.TSPropertySignature;
    from(params: {
        accessibility?: "public" | "private" | "protected" | undefined;
        comments?: Kinds.CommentKind[] | null;
        computed?: boolean;
        initializer?: Kinds.ExpressionKind | null;
        key: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        optional?: boolean;
        readonly?: boolean;
        static?: boolean;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.TSPropertySignature;
}

/** @public */
declare type TSPropertySignatureKind = namedTypes.TSPropertySignature;

/** @public */
declare interface TSQualifiedNameBuilder {
    (left: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, right: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind): namedTypes.TSQualifiedName;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        left: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
    }): namedTypes.TSQualifiedName;
}

/** @public */
declare type TSQualifiedNameKind = namedTypes.TSQualifiedName;

/** @public */
declare interface TSRestTypeBuilder {
    (typeAnnotation: Kinds.TSTypeKind): namedTypes.TSRestType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSRestType;
}

/** @public */
declare type TSRestTypeKind = namedTypes.TSRestType;

/** @public */
declare interface TSSatisfiesExpressionBuilder {
    (expression: Kinds.ExpressionKind, typeAnnotation: Kinds.TSTypeKind): namedTypes.TSSatisfiesExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSSatisfiesExpression;
}

/** @public */
declare type TSSatisfiesExpressionKind = namedTypes.TSSatisfiesExpression;

/** @public */
declare interface TSStringKeywordBuilder {
    (): namedTypes.TSStringKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSStringKeyword;
}

/** @public */
declare type TSStringKeywordKind = namedTypes.TSStringKeyword;

/** @public */
declare interface TSSymbolKeywordBuilder {
    (): namedTypes.TSSymbolKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSSymbolKeyword;
}

/** @public */
declare type TSSymbolKeywordKind = namedTypes.TSSymbolKeyword;

/** @public */
declare interface TSTemplateLiteralTypeBuilder {
    (quasis: Kinds.TemplateElementKind[], types: Kinds.TSTypeKind[]): namedTypes.TSTemplateLiteralType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        quasis: Kinds.TemplateElementKind[];
        types: Kinds.TSTypeKind[];
    }): namedTypes.TSTemplateLiteralType;
}

/** @public */
declare type TSTemplateLiteralTypeKind = namedTypes.TSTemplateLiteralType;

/** @public */
declare interface TSThisTypeBuilder {
    (): namedTypes.TSThisType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSThisType;
}

/** @public */
declare type TSThisTypeKind = namedTypes.TSThisType;

/** @public */
declare interface TSTupleTypeBuilder {
    (elementTypes: (Kinds.TSTypeKind | Kinds.TSNamedTupleMemberKind)[]): namedTypes.TSTupleType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elementTypes: (Kinds.TSTypeKind | Kinds.TSNamedTupleMemberKind)[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSTupleType;
}

/** @public */
declare type TSTupleTypeKind = namedTypes.TSTupleType;

/** @public */
declare interface TSTypeAliasDeclarationBuilder {
    (id: Kinds.IdentifierKind, typeAnnotation: Kinds.TSTypeKind): namedTypes.TSTypeAliasDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        declare?: boolean;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
        typeParameters?: Kinds.TSTypeParameterDeclarationKind | null | undefined;
    }): namedTypes.TSTypeAliasDeclaration;
}

/** @public */
declare type TSTypeAliasDeclarationKind = namedTypes.TSTypeAliasDeclaration;

/** @public */
declare interface TSTypeAnnotationBuilder {
    (typeAnnotation: Kinds.TSTypeKind | Kinds.TSTypeAnnotationKind): namedTypes.TSTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind | Kinds.TSTypeAnnotationKind;
    }): namedTypes.TSTypeAnnotation;
}

/** @public */
declare type TSTypeAnnotationKind = namedTypes.TSTypeAnnotation | namedTypes.TSTypePredicate;

/** @public */
declare interface TSTypeAssertionBuilder {
    (typeAnnotation: Kinds.TSTypeKind, expression: Kinds.ExpressionKind): namedTypes.TSTypeAssertion;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        extra?: {
            parenthesized: boolean;
        } | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSTypeAssertion;
}

/** @public */
declare type TSTypeAssertionKind = namedTypes.TSTypeAssertion;

/** @public */
declare interface TSTypeCastExpressionBuilder {
    (expression: Kinds.ExpressionKind, typeAnnotation: Kinds.TSTypeKind): namedTypes.TSTypeCastExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSTypeCastExpression;
}

/** @public */
declare type TSTypeCastExpressionKind = namedTypes.TSTypeCastExpression;

/** @public */
declare type TSTypeKind = namedTypes.TSExpressionWithTypeArguments | namedTypes.TSTypeReference | namedTypes.TSAnyKeyword | namedTypes.TSBigIntKeyword | namedTypes.TSBooleanKeyword | namedTypes.TSNeverKeyword | namedTypes.TSNullKeyword | namedTypes.TSNumberKeyword | namedTypes.TSObjectKeyword | namedTypes.TSStringKeyword | namedTypes.TSSymbolKeyword | namedTypes.TSUndefinedKeyword | namedTypes.TSUnknownKeyword | namedTypes.TSVoidKeyword | namedTypes.TSIntrinsicKeyword | namedTypes.TSThisType | namedTypes.TSArrayType | namedTypes.TSLiteralType | namedTypes.TSUnionType | namedTypes.TSIntersectionType | namedTypes.TSConditionalType | namedTypes.TSInferType | namedTypes.TSParenthesizedType | namedTypes.TSFunctionType | namedTypes.TSConstructorType | namedTypes.TSMappedType | namedTypes.TSTupleType | namedTypes.TSNamedTupleMember | namedTypes.TSRestType | namedTypes.TSOptionalType | namedTypes.TSIndexedAccessType | namedTypes.TSTypeOperator | namedTypes.TSTypePredicate | namedTypes.TSTypeQuery | namedTypes.TSImportType | namedTypes.TSTypeLiteral | namedTypes.TSTemplateLiteralType;

/** @public */
declare interface TSTypeLiteralBuilder {
    (members: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[]): namedTypes.TSTypeLiteral;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        members: (Kinds.TSCallSignatureDeclarationKind | Kinds.TSConstructSignatureDeclarationKind | Kinds.TSIndexSignatureKind | Kinds.TSMethodSignatureKind | Kinds.TSPropertySignatureKind)[];
    }): namedTypes.TSTypeLiteral;
}

/** @public */
declare type TSTypeLiteralKind = namedTypes.TSTypeLiteral;

/** @public */
declare interface TSTypeOperatorBuilder {
    (operator: string): namedTypes.TSTypeOperator;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        operator: string;
        typeAnnotation: Kinds.TSTypeKind;
    }): namedTypes.TSTypeOperator;
}

/** @public */
declare type TSTypeOperatorKind = namedTypes.TSTypeOperator;

/** @public */
declare interface TSTypeParameterBuilder {
    (name: Kinds.IdentifierKind | string, constraint?: Kinds.TSTypeKind | undefined, defaultParam?: Kinds.TSTypeKind | undefined): namedTypes.TSTypeParameter;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        const?: boolean;
        constraint?: Kinds.TSTypeKind | undefined;
        decorators?: Kinds.DecoratorKind[] | null;
        default?: Kinds.TSTypeKind | undefined;
        in?: boolean;
        loc?: Kinds.SourceLocationKind | null;
        name: Kinds.IdentifierKind | string;
        optional?: boolean;
        out?: boolean;
        typeAnnotation?: Kinds.TypeAnnotationKind | Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.TSTypeParameter;
}

/** @public */
declare interface TSTypeParameterDeclarationBuilder {
    (params: Kinds.TSTypeParameterKind[]): namedTypes.TSTypeParameterDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.TSTypeParameterKind[];
    }): namedTypes.TSTypeParameterDeclaration;
}

/** @public */
declare type TSTypeParameterDeclarationKind = namedTypes.TSTypeParameterDeclaration;

/** @public */
declare interface TSTypeParameterInstantiationBuilder {
    (params: Kinds.TSTypeKind[]): namedTypes.TSTypeParameterInstantiation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.TSTypeKind[];
    }): namedTypes.TSTypeParameterInstantiation;
}

/** @public */
declare type TSTypeParameterInstantiationKind = namedTypes.TSTypeParameterInstantiation;

/** @public */
declare type TSTypeParameterKind = namedTypes.TSTypeParameter;

/** @public */
declare interface TSTypePredicateBuilder {
    (parameterName: Kinds.IdentifierKind | Kinds.TSThisTypeKind, typeAnnotation?: Kinds.TSTypeAnnotationKind | null, asserts?: boolean): namedTypes.TSTypePredicate;
    from(params: {
        asserts?: boolean;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        parameterName: Kinds.IdentifierKind | Kinds.TSThisTypeKind;
        typeAnnotation?: Kinds.TSTypeAnnotationKind | null;
    }): namedTypes.TSTypePredicate;
}

/** @public */
declare type TSTypePredicateKind = namedTypes.TSTypePredicate;

/** @public */
declare interface TSTypeQueryBuilder {
    (exprName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSImportTypeKind): namedTypes.TSTypeQuery;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        exprName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind | Kinds.TSImportTypeKind;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSTypeQuery;
}

/** @public */
declare type TSTypeQueryKind = namedTypes.TSTypeQuery;

/** @public */
declare interface TSTypeReferenceBuilder {
    (typeName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind, typeParameters?: Kinds.TSTypeParameterInstantiationKind | null): namedTypes.TSTypeReference;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeArguments?: Kinds.TSTypeParameterInstantiationKind | null | undefined;
        typeName: Kinds.IdentifierKind | Kinds.TSQualifiedNameKind;
        typeParameters?: Kinds.TSTypeParameterInstantiationKind | null;
    }): namedTypes.TSTypeReference;
}

/** @public */
declare type TSTypeReferenceKind = namedTypes.TSTypeReference;

/** @public */
declare interface TSUndefinedKeywordBuilder {
    (): namedTypes.TSUndefinedKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSUndefinedKeyword;
}

/** @public */
declare type TSUndefinedKeywordKind = namedTypes.TSUndefinedKeyword;

/** @public */
declare interface TSUnionTypeBuilder {
    (types: Kinds.TSTypeKind[]): namedTypes.TSUnionType;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        types: Kinds.TSTypeKind[];
    }): namedTypes.TSUnionType;
}

/** @public */
declare type TSUnionTypeKind = namedTypes.TSUnionType;

/** @public */
declare interface TSUnknownKeywordBuilder {
    (): namedTypes.TSUnknownKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSUnknownKeyword;
}

/** @public */
declare type TSUnknownKeywordKind = namedTypes.TSUnknownKeyword;

/** @public */
declare interface TSVoidKeywordBuilder {
    (): namedTypes.TSVoidKeyword;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TSVoidKeyword;
}

/** @public */
declare type TSVoidKeywordKind = namedTypes.TSVoidKeyword;

/** @public */
declare interface TupleExpressionBuilder {
    (elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | null)[]): namedTypes.TupleExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        elements: (Kinds.ExpressionKind | Kinds.SpreadElementKind | null)[];
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TupleExpression;
}

/** @public */
declare type TupleExpressionKind = namedTypes.TupleExpression;

/** @public */
declare interface TupleTypeAnnotationBuilder {
    (types: Kinds.FlowTypeKind[]): namedTypes.TupleTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        types: Kinds.FlowTypeKind[];
    }): namedTypes.TupleTypeAnnotation;
}

/** @public */
declare type TupleTypeAnnotationKind = namedTypes.TupleTypeAnnotation;

declare type Type<T> = ArrayType<T> | IdentityType<T> | ObjectType<T> | OrType<T> | PredicateType<T>;

/** @public */
declare interface TypeAliasBuilder {
    (id: Kinds.IdentifierKind, typeParameters: Kinds.TypeParameterDeclarationKind | null, right: Kinds.FlowTypeKind): namedTypes.TypeAlias;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        id: Kinds.IdentifierKind;
        loc?: Kinds.SourceLocationKind | null;
        right: Kinds.FlowTypeKind;
        typeParameters: Kinds.TypeParameterDeclarationKind | null;
    }): namedTypes.TypeAlias;
}

/** @public */
declare type TypeAliasKind = namedTypes.TypeAlias | namedTypes.DeclareTypeAlias;

/** @public */
declare interface TypeAnnotationBuilder {
    (typeAnnotation: Kinds.FlowTypeKind): namedTypes.TypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.FlowTypeKind;
    }): namedTypes.TypeAnnotation;
}

/** @public */
declare type TypeAnnotationKind = namedTypes.TypeAnnotation;

/** @public */
declare interface TypeCastExpressionBuilder {
    (expression: Kinds.ExpressionKind, typeAnnotation: Kinds.TypeAnnotationKind): namedTypes.TypeCastExpression;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        expression: Kinds.ExpressionKind;
        loc?: Kinds.SourceLocationKind | null;
        typeAnnotation: Kinds.TypeAnnotationKind;
    }): namedTypes.TypeCastExpression;
}

/** @public */
declare type TypeCastExpressionKind = namedTypes.TypeCastExpression;

/** @public */
declare interface TypeofTypeAnnotationBuilder {
    (argument: Kinds.FlowTypeKind): namedTypes.TypeofTypeAnnotation;
    from(params: {
        argument: Kinds.FlowTypeKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.TypeofTypeAnnotation;
}

/** @public */
declare type TypeofTypeAnnotationKind = namedTypes.TypeofTypeAnnotation;

/** @public */
declare interface TypeParameterBuilder {
    (name: string, variance?: Kinds.VarianceKind | "plus" | "minus" | null, bound?: Kinds.TypeAnnotationKind | null, defaultParam?: Kinds.FlowTypeKind | null): namedTypes.TypeParameter;
    from(params: {
        bound?: Kinds.TypeAnnotationKind | null;
        comments?: Kinds.CommentKind[] | null;
        default?: Kinds.FlowTypeKind | null;
        loc?: Kinds.SourceLocationKind | null;
        name: string;
        variance?: Kinds.VarianceKind | "plus" | "minus" | null;
    }): namedTypes.TypeParameter;
}

/** @public */
declare interface TypeParameterDeclarationBuilder {
    (params: Kinds.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.TypeParameterKind[];
    }): namedTypes.TypeParameterDeclaration;
}

/** @public */
declare type TypeParameterDeclarationKind = namedTypes.TypeParameterDeclaration;

/** @public */
declare interface TypeParameterInstantiationBuilder {
    (params: Kinds.FlowTypeKind[]): namedTypes.TypeParameterInstantiation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        params: Kinds.FlowTypeKind[];
    }): namedTypes.TypeParameterInstantiation;
}

/** @public */
declare type TypeParameterInstantiationKind = namedTypes.TypeParameterInstantiation;

/** @public */
declare type TypeParameterKind = namedTypes.TypeParameter;

/** @public */
declare interface UnaryExpressionBuilder {
    (operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete", argument: Kinds.ExpressionKind, prefix?: boolean): namedTypes.UnaryExpression;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
        prefix?: boolean;
    }): namedTypes.UnaryExpression;
}

/** @public */
declare type UnaryExpressionKind = namedTypes.UnaryExpression;

/** @public */
declare interface UnionTypeAnnotationBuilder {
    (types: Kinds.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        types: Kinds.FlowTypeKind[];
    }): namedTypes.UnionTypeAnnotation;
}

/** @public */
declare type UnionTypeAnnotationKind = namedTypes.UnionTypeAnnotation;

/** @public */
declare interface UpdateExpressionBuilder {
    (operator: "++" | "--", argument: Kinds.ExpressionKind, prefix: boolean): namedTypes.UpdateExpression;
    from(params: {
        argument: Kinds.ExpressionKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        operator: "++" | "--";
        prefix: boolean;
    }): namedTypes.UpdateExpression;
}

/** @public */
declare type UpdateExpressionKind = namedTypes.UpdateExpression;

declare const utils: {
    traverseTemplateAST: (node: AST.Node, visitor: {
        enterNode?(node: AST.Node, parent: AST.Node | null): void;
        leaveNode?(node: AST.Node, parent: AST.Node | null): void;
    }) => void;
    traverseScriptAST: <M = {}>(node: ASTNode, methods?: Visitor<M>) => any;
    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;
        privateIdentifier: PrivateIdentifierBuilder;
        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;
        propertyDefinition: PropertyDefinitionBuilder;
        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;
        tsEnumBody: TSEnumBodyBuilder;
        tsInterfaceHeritage: TSInterfaceHeritageBuilder;
        tsClassImplements: TSClassImplementsBuilder;
        tsTemplateLiteralType: TSTemplateLiteralTypeBuilder;
        tsEmptyBodyFunctionExpression: TSEmptyBodyFunctionExpressionBuilder;
        tsAbstractMethodDefinition: TSAbstractMethodDefinitionBuilder;
        tsAbstractPropertyDefinition: TSAbstractPropertyDefinitionBuilder;
        setParents(node: AST.Node): void;
        vAttribute(key: AST.VAttribute["key"], value: AST.VAttribute["value"]): AST.VAttribute;
        vDirective(key: AST.VDirective["key"], value: AST.VDirective["value"]): AST.VDirective;
        vDirectiveKey(name: AST.VDirectiveKey["name"], argument?: AST.VDirectiveKey["argument"], modifiers?: AST.VDirectiveKey["modifiers"]): AST.VDirectiveKey;
        vDocumentFragment(children: AST.VDocumentFragment["children"]): AST.VDocumentFragment;
        vEndTag(leadingComment?: AST.HtmlComment): AST.VEndTag;
        vElement(name: string, startTag: AST.VStartTag, children: AST.VElement["children"], namespace?: AST.VElement["namespace"]): AST.VElement;
        vExpressionContainer(expression: AST.VExpressionContainer["expression"], leadingComment?: AST.HtmlComment): AST.VExpressionContainer;
        vForExpression(left: AST.VForExpression["left"], right: AST.VForExpression["right"]): AST.VForExpression;
        vIdentifier(name: AST.VIdentifier["name"], rawName?: AST.VIdentifier["rawName"]): AST.VIdentifier;
        vLiteral(value: AST.VLiteral["value"]): AST.VLiteral;
        vStartTag(attributes: AST.VStartTag["attributes"], selfClosing: AST.VStartTag["selfClosing"], leadingComment?: AST.HtmlComment): AST.VStartTag;
        vText(value: AST.VText["value"], leadingComment?: AST.HtmlComment): AST.VText;
        vOnExpression(body: AST.VOnExpression["body"]): AST.VOnExpression;
        vFilterSequenceExpression(expression: AST.VFilterSequenceExpression["expression"], filters: AST.VFilterSequenceExpression["filters"]): AST.VFilterSequenceExpression;
        vFilter(callee: AST.VFilter["callee"], args: AST.VFilter["arguments"]): AST.VFilter;
        htmlComment(value: string, leadingComment?: AST.HtmlComment): AST.HtmlComment;
    };
    astHelpers: typeof astHelpers_2;
};

/** @public */
declare interface V8IntrinsicIdentifierBuilder {
    (name: string): namedTypes.V8IntrinsicIdentifier;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        name: string;
    }): namedTypes.V8IntrinsicIdentifier;
}

/** @public */
declare type V8IntrinsicIdentifierKind = namedTypes.V8IntrinsicIdentifier;

/** @public */
declare interface VariableDeclarationBuilder {
    (kind: "var" | "let" | "const", declarations: (Kinds.VariableDeclaratorKind | Kinds.IdentifierKind)[]): namedTypes.VariableDeclaration;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        declarations: (Kinds.VariableDeclaratorKind | Kinds.IdentifierKind)[];
        declare?: boolean;
        kind: "var" | "let" | "const";
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.VariableDeclaration;
}

/** @public */
declare type VariableDeclarationKind = namedTypes.VariableDeclaration;

/** @public */
declare interface VariableDeclaratorBuilder {
    (id: Kinds.PatternKind, init?: Kinds.ExpressionKind | null): namedTypes.VariableDeclarator;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        definite?: boolean;
        id: Kinds.PatternKind;
        init?: Kinds.ExpressionKind | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.VariableDeclarator;
}

/** @public */
declare type VariableDeclaratorKind = namedTypes.VariableDeclarator;

/** @public */
declare interface VarianceBuilder {
    (kind: "plus" | "minus"): namedTypes.Variance;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        kind: "plus" | "minus";
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.Variance;
}

/** @public */
declare type VarianceKind = namedTypes.Variance;

/**
 * Static attribute nodes.
 * @public
 */
declare interface VAttribute extends HasParent {
    type: 'VAttribute';
    parent: VStartTag;
    directive: false;
    key: VIdentifier;
    value: VLiteral | null;
}

/**
 * Directive nodes.
 * @public
 */
declare interface VDirective extends HasParent {
    type: 'VAttribute';
    parent: VStartTag;
    directive: true;
    key: VDirectiveKey;
    value: VExpressionContainer | null;
}

/**
 * Attribute name nodes.
 * @public
 */
declare interface VDirectiveKey extends HasParent {
    type: 'VDirectiveKey';
    parent: VDirective;
    name: VIdentifier;
    argument: VExpressionContainer | VIdentifier | null;
    modifiers: VIdentifier[];
}

/**
 * Root nodes.
 * @public
 */
declare interface VDocumentFragment extends HasParent {
    type: 'VDocumentFragment';
    parent: null;
    children: (VElement | VText | VExpressionContainer | VStyleElement)[];
}

/**
 * Element nodes.
 * @public
 */
declare interface VElement extends HasParent {
    type: 'VElement';
    parent: VDocumentFragment | VElement;
    namespace: Namespace;
    name: string;
    rawName: string;
    startTag: VStartTag;
    children: (VElement | VText | VExpressionContainer)[];
    endTag: VEndTag | null;
}

/**
 * End tag nodes.
 * @public
 */
declare interface VEndTag extends HasParent, HasLeadingComment {
    type: 'VEndTag';
    parent: VElement;
}

/**
 * The node of JavaScript expression in text.
 * e.g. `{{ name }}`
 * @public
 */
declare interface VExpressionContainer extends HasParent, HasLeadingComment {
    type: 'VExpressionContainer';
    parent: VDocumentFragment | VElement | VDirective | VDirectiveKey;
    expression: ExpressionKind | PatternKind | VFilterSequenceExpression | VForExpression | VOnExpression | VSlotScopeExpression | VGenericExpression | null;
}

/**
 * The node of a filter sequence which is separated by `|`.
 * @public
 */
declare interface VFilter extends HasParent {
    type: 'VFilter';
    parent: VFilterSequenceExpression;
    callee: namedTypes.Identifier;
    arguments: (ExpressionKind | namedTypes.SpreadElement)[];
}

/**
 * The node of a filter sequence which is separated by `|`.
 * @public
 */
declare interface VFilterSequenceExpression extends HasParent {
    type: 'VFilterSequenceExpression';
    parent: VExpressionContainer;
    expression: ExpressionKind;
    filters: VFilter[];
}

/**
 * The node of `v-for` directives.
 * @public
 */
declare interface VForExpression extends HasParent {
    type: 'VForExpression';
    parent: VExpressionContainer;
    left: PatternKind[];
    right: ExpressionKind;
}

/**
 * The generic expression on a \<script setup lang="ts" generic="..."\> node
 * @public
 */
declare interface VGenericExpression extends HasParent {
    type: 'VGenericExpression';
    parent: VExpressionContainer;
    params: namedTypes.TSTypeParameterDeclaration['params'];
    rawParams: string[];
}

/**
 * Attribute name nodes.
 * @public
 */
declare interface VIdentifier extends HasParent {
    type: 'VIdentifier';
    parent: VAttribute | VDirectiveKey;
    name: string;
    rawName: string;
}

/** @public */
declare interface Visitor<M = {}> {
    visitPrintable?(this: Context & M, path: NodePath<namedTypes.Printable>): any;
    visitSourceLocation?(this: Context & M, path: NodePath<namedTypes.SourceLocation>): any;
    visitNode?(this: Context & M, path: NodePath<namedTypes.Node>): any;
    visitComment?(this: Context & M, path: NodePath<namedTypes.Comment>): any;
    visitPosition?(this: Context & M, path: NodePath<namedTypes.Position>): any;
    visitFile?(this: Context & M, path: NodePath<namedTypes.File>): any;
    visitProgram?(this: Context & M, path: NodePath<namedTypes.Program>): any;
    visitStatement?(this: Context & M, path: NodePath<namedTypes.Statement>): any;
    visitFunction?(this: Context & M, path: NodePath<namedTypes.Function>): any;
    visitExpression?(this: Context & M, path: NodePath<namedTypes.Expression>): any;
    visitPattern?(this: Context & M, path: NodePath<namedTypes.Pattern>): any;
    visitIdentifier?(this: Context & M, path: NodePath<namedTypes.Identifier>): any;
    visitBlockStatement?(this: Context & M, path: NodePath<namedTypes.BlockStatement>): any;
    visitEmptyStatement?(this: Context & M, path: NodePath<namedTypes.EmptyStatement>): any;
    visitExpressionStatement?(this: Context & M, path: NodePath<namedTypes.ExpressionStatement>): any;
    visitIfStatement?(this: Context & M, path: NodePath<namedTypes.IfStatement>): any;
    visitLabeledStatement?(this: Context & M, path: NodePath<namedTypes.LabeledStatement>): any;
    visitBreakStatement?(this: Context & M, path: NodePath<namedTypes.BreakStatement>): any;
    visitContinueStatement?(this: Context & M, path: NodePath<namedTypes.ContinueStatement>): any;
    visitWithStatement?(this: Context & M, path: NodePath<namedTypes.WithStatement>): any;
    visitSwitchStatement?(this: Context & M, path: NodePath<namedTypes.SwitchStatement>): any;
    visitSwitchCase?(this: Context & M, path: NodePath<namedTypes.SwitchCase>): any;
    visitReturnStatement?(this: Context & M, path: NodePath<namedTypes.ReturnStatement>): any;
    visitThrowStatement?(this: Context & M, path: NodePath<namedTypes.ThrowStatement>): any;
    visitTryStatement?(this: Context & M, path: NodePath<namedTypes.TryStatement>): any;
    visitCatchClause?(this: Context & M, path: NodePath<namedTypes.CatchClause>): any;
    visitWhileStatement?(this: Context & M, path: NodePath<namedTypes.WhileStatement>): any;
    visitDoWhileStatement?(this: Context & M, path: NodePath<namedTypes.DoWhileStatement>): any;
    visitForStatement?(this: Context & M, path: NodePath<namedTypes.ForStatement>): any;
    visitDeclaration?(this: Context & M, path: NodePath<namedTypes.Declaration>): any;
    visitVariableDeclaration?(this: Context & M, path: NodePath<namedTypes.VariableDeclaration>): any;
    visitForInStatement?(this: Context & M, path: NodePath<namedTypes.ForInStatement>): any;
    visitDebuggerStatement?(this: Context & M, path: NodePath<namedTypes.DebuggerStatement>): any;
    visitFunctionDeclaration?(this: Context & M, path: NodePath<namedTypes.FunctionDeclaration>): any;
    visitFunctionExpression?(this: Context & M, path: NodePath<namedTypes.FunctionExpression>): any;
    visitVariableDeclarator?(this: Context & M, path: NodePath<namedTypes.VariableDeclarator>): any;
    visitThisExpression?(this: Context & M, path: NodePath<namedTypes.ThisExpression>): any;
    visitArrayExpression?(this: Context & M, path: NodePath<namedTypes.ArrayExpression>): any;
    visitObjectExpression?(this: Context & M, path: NodePath<namedTypes.ObjectExpression>): any;
    visitProperty?(this: Context & M, path: NodePath<namedTypes.Property>): any;
    visitLiteral?(this: Context & M, path: NodePath<namedTypes.Literal>): any;
    visitSequenceExpression?(this: Context & M, path: NodePath<namedTypes.SequenceExpression>): any;
    visitUnaryExpression?(this: Context & M, path: NodePath<namedTypes.UnaryExpression>): any;
    visitBinaryExpression?(this: Context & M, path: NodePath<namedTypes.BinaryExpression>): any;
    visitAssignmentExpression?(this: Context & M, path: NodePath<namedTypes.AssignmentExpression>): any;
    visitChainElement?(this: Context & M, path: NodePath<namedTypes.ChainElement>): any;
    visitMemberExpression?(this: Context & M, path: NodePath<namedTypes.MemberExpression>): any;
    visitUpdateExpression?(this: Context & M, path: NodePath<namedTypes.UpdateExpression>): any;
    visitLogicalExpression?(this: Context & M, path: NodePath<namedTypes.LogicalExpression>): any;
    visitConditionalExpression?(this: Context & M, path: NodePath<namedTypes.ConditionalExpression>): any;
    visitNewExpression?(this: Context & M, path: NodePath<namedTypes.NewExpression>): any;
    visitTSHasOptionalTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeParameterInstantiation>): any;
    visitCallExpression?(this: Context & M, path: NodePath<namedTypes.CallExpression>): any;
    visitRestElement?(this: Context & M, path: NodePath<namedTypes.RestElement>): any;
    visitTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TypeAnnotation>): any;
    visitTSTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TSTypeAnnotation>): any;
    visitSpreadElementPattern?(this: Context & M, path: NodePath<namedTypes.SpreadElementPattern>): any;
    visitArrowFunctionExpression?(this: Context & M, path: NodePath<namedTypes.ArrowFunctionExpression>): any;
    visitForOfStatement?(this: Context & M, path: NodePath<namedTypes.ForOfStatement>): any;
    visitYieldExpression?(this: Context & M, path: NodePath<namedTypes.YieldExpression>): any;
    visitGeneratorExpression?(this: Context & M, path: NodePath<namedTypes.GeneratorExpression>): any;
    visitComprehensionBlock?(this: Context & M, path: NodePath<namedTypes.ComprehensionBlock>): any;
    visitComprehensionExpression?(this: Context & M, path: NodePath<namedTypes.ComprehensionExpression>): any;
    visitObjectProperty?(this: Context & M, path: NodePath<namedTypes.ObjectProperty>): any;
    visitPropertyPattern?(this: Context & M, path: NodePath<namedTypes.PropertyPattern>): any;
    visitObjectPattern?(this: Context & M, path: NodePath<namedTypes.ObjectPattern>): any;
    visitArrayPattern?(this: Context & M, path: NodePath<namedTypes.ArrayPattern>): any;
    visitSpreadElement?(this: Context & M, path: NodePath<namedTypes.SpreadElement>): any;
    visitAssignmentPattern?(this: Context & M, path: NodePath<namedTypes.AssignmentPattern>): any;
    visitMethodDefinition?(this: Context & M, path: NodePath<namedTypes.MethodDefinition>): any;
    visitClassPropertyDefinition?(this: Context & M, path: NodePath<namedTypes.ClassPropertyDefinition>): any;
    visitClassProperty?(this: Context & M, path: NodePath<namedTypes.ClassProperty>): any;
    visitStaticBlock?(this: Context & M, path: NodePath<namedTypes.StaticBlock>): any;
    visitClassBody?(this: Context & M, path: NodePath<namedTypes.ClassBody>): any;
    visitClassDeclaration?(this: Context & M, path: NodePath<namedTypes.ClassDeclaration>): any;
    visitClassExpression?(this: Context & M, path: NodePath<namedTypes.ClassExpression>): any;
    visitSuper?(this: Context & M, path: NodePath<namedTypes.Super>): any;
    visitSpecifier?(this: Context & M, path: NodePath<namedTypes.Specifier>): any;
    visitModuleSpecifier?(this: Context & M, path: NodePath<namedTypes.ModuleSpecifier>): any;
    visitImportSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportSpecifier>): any;
    visitImportDefaultSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportDefaultSpecifier>): any;
    visitImportNamespaceSpecifier?(this: Context & M, path: NodePath<namedTypes.ImportNamespaceSpecifier>): any;
    visitImportDeclaration?(this: Context & M, path: NodePath<namedTypes.ImportDeclaration>): any;
    visitExportNamedDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportNamedDeclaration>): any;
    visitExportSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportSpecifier>): any;
    visitExportDefaultDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportDefaultDeclaration>): any;
    visitExportAllDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportAllDeclaration>): any;
    visitTaggedTemplateExpression?(this: Context & M, path: NodePath<namedTypes.TaggedTemplateExpression>): any;
    visitTemplateLiteral?(this: Context & M, path: NodePath<namedTypes.TemplateLiteral>): any;
    visitTemplateElement?(this: Context & M, path: NodePath<namedTypes.TemplateElement>): any;
    visitMetaProperty?(this: Context & M, path: NodePath<namedTypes.MetaProperty>): any;
    visitAwaitExpression?(this: Context & M, path: NodePath<namedTypes.AwaitExpression>): any;
    visitSpreadProperty?(this: Context & M, path: NodePath<namedTypes.SpreadProperty>): any;
    visitSpreadPropertyPattern?(this: Context & M, path: NodePath<namedTypes.SpreadPropertyPattern>): any;
    visitImportExpression?(this: Context & M, path: NodePath<namedTypes.ImportExpression>): any;
    visitChainExpression?(this: Context & M, path: NodePath<namedTypes.ChainExpression>): any;
    visitOptionalCallExpression?(this: Context & M, path: NodePath<namedTypes.OptionalCallExpression>): any;
    visitOptionalMemberExpression?(this: Context & M, path: NodePath<namedTypes.OptionalMemberExpression>): any;
    visitPrivateIdentifier?(this: Context & M, path: NodePath<namedTypes.PrivateIdentifier>): any;
    visitDecorator?(this: Context & M, path: NodePath<namedTypes.Decorator>): any;
    visitPrivateName?(this: Context & M, path: NodePath<namedTypes.PrivateName>): any;
    visitClassPrivateProperty?(this: Context & M, path: NodePath<namedTypes.ClassPrivateProperty>): any;
    visitImportAttribute?(this: Context & M, path: NodePath<namedTypes.ImportAttribute>): any;
    visitRecordExpression?(this: Context & M, path: NodePath<namedTypes.RecordExpression>): any;
    visitObjectMethod?(this: Context & M, path: NodePath<namedTypes.ObjectMethod>): any;
    visitTupleExpression?(this: Context & M, path: NodePath<namedTypes.TupleExpression>): any;
    visitModuleExpression?(this: Context & M, path: NodePath<namedTypes.ModuleExpression>): any;
    visitJSXAttribute?(this: Context & M, path: NodePath<namedTypes.JSXAttribute>): any;
    visitJSXIdentifier?(this: Context & M, path: NodePath<namedTypes.JSXIdentifier>): any;
    visitJSXNamespacedName?(this: Context & M, path: NodePath<namedTypes.JSXNamespacedName>): any;
    visitJSXExpressionContainer?(this: Context & M, path: NodePath<namedTypes.JSXExpressionContainer>): any;
    visitJSXElement?(this: Context & M, path: NodePath<namedTypes.JSXElement>): any;
    visitJSXFragment?(this: Context & M, path: NodePath<namedTypes.JSXFragment>): any;
    visitJSXMemberExpression?(this: Context & M, path: NodePath<namedTypes.JSXMemberExpression>): any;
    visitJSXSpreadAttribute?(this: Context & M, path: NodePath<namedTypes.JSXSpreadAttribute>): any;
    visitJSXEmptyExpression?(this: Context & M, path: NodePath<namedTypes.JSXEmptyExpression>): any;
    visitJSXText?(this: Context & M, path: NodePath<namedTypes.JSXText>): any;
    visitJSXSpreadChild?(this: Context & M, path: NodePath<namedTypes.JSXSpreadChild>): any;
    visitJSXOpeningElement?(this: Context & M, path: NodePath<namedTypes.JSXOpeningElement>): any;
    visitJSXClosingElement?(this: Context & M, path: NodePath<namedTypes.JSXClosingElement>): any;
    visitJSXOpeningFragment?(this: Context & M, path: NodePath<namedTypes.JSXOpeningFragment>): any;
    visitJSXClosingFragment?(this: Context & M, path: NodePath<namedTypes.JSXClosingFragment>): any;
    visitTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TypeParameterDeclaration>): any;
    visitTSTypeParameterDeclaration?(this: Context & M, path: NodePath<namedTypes.TSTypeParameterDeclaration>): any;
    visitTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TypeParameterInstantiation>): any;
    visitTSTypeParameterInstantiation?(this: Context & M, path: NodePath<namedTypes.TSTypeParameterInstantiation>): any;
    visitClassImplements?(this: Context & M, path: NodePath<namedTypes.ClassImplements>): any;
    visitTSType?(this: Context & M, path: NodePath<namedTypes.TSType>): any;
    visitTSExpressionWithTypeArguments?(this: Context & M, path: NodePath<namedTypes.TSExpressionWithTypeArguments>): any;
    visitFlow?(this: Context & M, path: NodePath<namedTypes.Flow>): any;
    visitFlowType?(this: Context & M, path: NodePath<namedTypes.FlowType>): any;
    visitAnyTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.AnyTypeAnnotation>): any;
    visitEmptyTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.EmptyTypeAnnotation>): any;
    visitMixedTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.MixedTypeAnnotation>): any;
    visitVoidTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.VoidTypeAnnotation>): any;
    visitSymbolTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.SymbolTypeAnnotation>): any;
    visitNumberTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumberTypeAnnotation>): any;
    visitBigIntTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BigIntTypeAnnotation>): any;
    visitNumberLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumberLiteralTypeAnnotation>): any;
    visitNumericLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NumericLiteralTypeAnnotation>): any;
    visitBigIntLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BigIntLiteralTypeAnnotation>): any;
    visitStringTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.StringTypeAnnotation>): any;
    visitStringLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.StringLiteralTypeAnnotation>): any;
    visitBooleanTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BooleanTypeAnnotation>): any;
    visitBooleanLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.BooleanLiteralTypeAnnotation>): any;
    visitNullableTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullableTypeAnnotation>): any;
    visitNullLiteralTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullLiteralTypeAnnotation>): any;
    visitNullTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.NullTypeAnnotation>): any;
    visitThisTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ThisTypeAnnotation>): any;
    visitExistsTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ExistsTypeAnnotation>): any;
    visitExistentialTypeParam?(this: Context & M, path: NodePath<namedTypes.ExistentialTypeParam>): any;
    visitFunctionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.FunctionTypeAnnotation>): any;
    visitFunctionTypeParam?(this: Context & M, path: NodePath<namedTypes.FunctionTypeParam>): any;
    visitArrayTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ArrayTypeAnnotation>): any;
    visitObjectTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.ObjectTypeAnnotation>): any;
    visitObjectTypeProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeProperty>): any;
    visitObjectTypeSpreadProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeSpreadProperty>): any;
    visitObjectTypeIndexer?(this: Context & M, path: NodePath<namedTypes.ObjectTypeIndexer>): any;
    visitObjectTypeCallProperty?(this: Context & M, path: NodePath<namedTypes.ObjectTypeCallProperty>): any;
    visitObjectTypeInternalSlot?(this: Context & M, path: NodePath<namedTypes.ObjectTypeInternalSlot>): any;
    visitVariance?(this: Context & M, path: NodePath<namedTypes.Variance>): any;
    visitQualifiedTypeIdentifier?(this: Context & M, path: NodePath<namedTypes.QualifiedTypeIdentifier>): any;
    visitGenericTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.GenericTypeAnnotation>): any;
    visitMemberTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.MemberTypeAnnotation>): any;
    visitIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.IndexedAccessType>): any;
    visitOptionalIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.OptionalIndexedAccessType>): any;
    visitUnionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.UnionTypeAnnotation>): any;
    visitIntersectionTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.IntersectionTypeAnnotation>): any;
    visitTypeofTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TypeofTypeAnnotation>): any;
    visitTypeParameter?(this: Context & M, path: NodePath<namedTypes.TypeParameter>): any;
    visitPropertyDefinition?(this: Context & M, path: NodePath<namedTypes.PropertyDefinition>): any;
    visitInterfaceTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.InterfaceTypeAnnotation>): any;
    visitInterfaceExtends?(this: Context & M, path: NodePath<namedTypes.InterfaceExtends>): any;
    visitInterfaceDeclaration?(this: Context & M, path: NodePath<namedTypes.InterfaceDeclaration>): any;
    visitDeclareInterface?(this: Context & M, path: NodePath<namedTypes.DeclareInterface>): any;
    visitTypeAlias?(this: Context & M, path: NodePath<namedTypes.TypeAlias>): any;
    visitDeclareTypeAlias?(this: Context & M, path: NodePath<namedTypes.DeclareTypeAlias>): any;
    visitOpaqueType?(this: Context & M, path: NodePath<namedTypes.OpaqueType>): any;
    visitDeclareOpaqueType?(this: Context & M, path: NodePath<namedTypes.DeclareOpaqueType>): any;
    visitTypeCastExpression?(this: Context & M, path: NodePath<namedTypes.TypeCastExpression>): any;
    visitTupleTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TupleTypeAnnotation>): any;
    visitDeclareVariable?(this: Context & M, path: NodePath<namedTypes.DeclareVariable>): any;
    visitDeclareFunction?(this: Context & M, path: NodePath<namedTypes.DeclareFunction>): any;
    visitFlowPredicate?(this: Context & M, path: NodePath<namedTypes.FlowPredicate>): any;
    visitDeclareClass?(this: Context & M, path: NodePath<namedTypes.DeclareClass>): any;
    visitDeclareModule?(this: Context & M, path: NodePath<namedTypes.DeclareModule>): any;
    visitDeclareModuleExports?(this: Context & M, path: NodePath<namedTypes.DeclareModuleExports>): any;
    visitDeclareExportDeclaration?(this: Context & M, path: NodePath<namedTypes.DeclareExportDeclaration>): any;
    visitExportBatchSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportBatchSpecifier>): any;
    visitDeclareExportAllDeclaration?(this: Context & M, path: NodePath<namedTypes.DeclareExportAllDeclaration>): any;
    visitInferredPredicate?(this: Context & M, path: NodePath<namedTypes.InferredPredicate>): any;
    visitDeclaredPredicate?(this: Context & M, path: NodePath<namedTypes.DeclaredPredicate>): any;
    visitEnumDeclaration?(this: Context & M, path: NodePath<namedTypes.EnumDeclaration>): any;
    visitEnumBooleanBody?(this: Context & M, path: NodePath<namedTypes.EnumBooleanBody>): any;
    visitEnumNumberBody?(this: Context & M, path: NodePath<namedTypes.EnumNumberBody>): any;
    visitEnumStringBody?(this: Context & M, path: NodePath<namedTypes.EnumStringBody>): any;
    visitEnumSymbolBody?(this: Context & M, path: NodePath<namedTypes.EnumSymbolBody>): any;
    visitEnumBooleanMember?(this: Context & M, path: NodePath<namedTypes.EnumBooleanMember>): any;
    visitEnumNumberMember?(this: Context & M, path: NodePath<namedTypes.EnumNumberMember>): any;
    visitEnumStringMember?(this: Context & M, path: NodePath<namedTypes.EnumStringMember>): any;
    visitEnumDefaultedMember?(this: Context & M, path: NodePath<namedTypes.EnumDefaultedMember>): any;
    visitExportDeclaration?(this: Context & M, path: NodePath<namedTypes.ExportDeclaration>): any;
    visitBlock?(this: Context & M, path: NodePath<namedTypes.Block>): any;
    visitLine?(this: Context & M, path: NodePath<namedTypes.Line>): any;
    visitNoop?(this: Context & M, path: NodePath<namedTypes.Noop>): any;
    visitDoExpression?(this: Context & M, path: NodePath<namedTypes.DoExpression>): any;
    visitBindExpression?(this: Context & M, path: NodePath<namedTypes.BindExpression>): any;
    visitParenthesizedExpression?(this: Context & M, path: NodePath<namedTypes.ParenthesizedExpression>): any;
    visitExportNamespaceSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportNamespaceSpecifier>): any;
    visitExportDefaultSpecifier?(this: Context & M, path: NodePath<namedTypes.ExportDefaultSpecifier>): any;
    visitCommentBlock?(this: Context & M, path: NodePath<namedTypes.CommentBlock>): any;
    visitCommentLine?(this: Context & M, path: NodePath<namedTypes.CommentLine>): any;
    visitDirective?(this: Context & M, path: NodePath<namedTypes.Directive>): any;
    visitDirectiveLiteral?(this: Context & M, path: NodePath<namedTypes.DirectiveLiteral>): any;
    visitInterpreterDirective?(this: Context & M, path: NodePath<namedTypes.InterpreterDirective>): any;
    visitStringLiteral?(this: Context & M, path: NodePath<namedTypes.StringLiteral>): any;
    visitNumericLiteral?(this: Context & M, path: NodePath<namedTypes.NumericLiteral>): any;
    visitBigIntLiteral?(this: Context & M, path: NodePath<namedTypes.BigIntLiteral>): any;
    visitDecimalLiteral?(this: Context & M, path: NodePath<namedTypes.DecimalLiteral>): any;
    visitNullLiteral?(this: Context & M, path: NodePath<namedTypes.NullLiteral>): any;
    visitBooleanLiteral?(this: Context & M, path: NodePath<namedTypes.BooleanLiteral>): any;
    visitRegExpLiteral?(this: Context & M, path: NodePath<namedTypes.RegExpLiteral>): any;
    visitClassMethod?(this: Context & M, path: NodePath<namedTypes.ClassMethod>): any;
    visitClassPrivateMethod?(this: Context & M, path: NodePath<namedTypes.ClassPrivateMethod>): any;
    visitTSHasOptionalTypeAnnotation?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeAnnotation>): any;
    visitClassAccessorProperty?(this: Context & M, path: NodePath<namedTypes.ClassAccessorProperty>): any;
    visitRestProperty?(this: Context & M, path: NodePath<namedTypes.RestProperty>): any;
    visitForAwaitStatement?(this: Context & M, path: NodePath<namedTypes.ForAwaitStatement>): any;
    visitImport?(this: Context & M, path: NodePath<namedTypes.Import>): any;
    visitV8IntrinsicIdentifier?(this: Context & M, path: NodePath<namedTypes.V8IntrinsicIdentifier>): any;
    visitTopicReference?(this: Context & M, path: NodePath<namedTypes.TopicReference>): any;
    visitTSQualifiedName?(this: Context & M, path: NodePath<namedTypes.TSQualifiedName>): any;
    visitTSTypeReference?(this: Context & M, path: NodePath<namedTypes.TSTypeReference>): any;
    visitTSHasOptionalTypeParameters?(this: Context & M, path: NodePath<namedTypes.TSHasOptionalTypeParameters>): any;
    visitTSAsExpression?(this: Context & M, path: NodePath<namedTypes.TSAsExpression>): any;
    visitTSTypeCastExpression?(this: Context & M, path: NodePath<namedTypes.TSTypeCastExpression>): any;
    visitTSSatisfiesExpression?(this: Context & M, path: NodePath<namedTypes.TSSatisfiesExpression>): any;
    visitTSNonNullExpression?(this: Context & M, path: NodePath<namedTypes.TSNonNullExpression>): any;
    visitTSAnyKeyword?(this: Context & M, path: NodePath<namedTypes.TSAnyKeyword>): any;
    visitTSBigIntKeyword?(this: Context & M, path: NodePath<namedTypes.TSBigIntKeyword>): any;
    visitTSBooleanKeyword?(this: Context & M, path: NodePath<namedTypes.TSBooleanKeyword>): any;
    visitTSNeverKeyword?(this: Context & M, path: NodePath<namedTypes.TSNeverKeyword>): any;
    visitTSNullKeyword?(this: Context & M, path: NodePath<namedTypes.TSNullKeyword>): any;
    visitTSNumberKeyword?(this: Context & M, path: NodePath<namedTypes.TSNumberKeyword>): any;
    visitTSObjectKeyword?(this: Context & M, path: NodePath<namedTypes.TSObjectKeyword>): any;
    visitTSStringKeyword?(this: Context & M, path: NodePath<namedTypes.TSStringKeyword>): any;
    visitTSSymbolKeyword?(this: Context & M, path: NodePath<namedTypes.TSSymbolKeyword>): any;
    visitTSUndefinedKeyword?(this: Context & M, path: NodePath<namedTypes.TSUndefinedKeyword>): any;
    visitTSUnknownKeyword?(this: Context & M, path: NodePath<namedTypes.TSUnknownKeyword>): any;
    visitTSVoidKeyword?(this: Context & M, path: NodePath<namedTypes.TSVoidKeyword>): any;
    visitTSIntrinsicKeyword?(this: Context & M, path: NodePath<namedTypes.TSIntrinsicKeyword>): any;
    visitTSThisType?(this: Context & M, path: NodePath<namedTypes.TSThisType>): any;
    visitTSArrayType?(this: Context & M, path: NodePath<namedTypes.TSArrayType>): any;
    visitTSLiteralType?(this: Context & M, path: NodePath<namedTypes.TSLiteralType>): any;
    visitTSUnionType?(this: Context & M, path: NodePath<namedTypes.TSUnionType>): any;
    visitTSIntersectionType?(this: Context & M, path: NodePath<namedTypes.TSIntersectionType>): any;
    visitTSConditionalType?(this: Context & M, path: NodePath<namedTypes.TSConditionalType>): any;
    visitTSInferType?(this: Context & M, path: NodePath<namedTypes.TSInferType>): any;
    visitTSTypeParameter?(this: Context & M, path: NodePath<namedTypes.TSTypeParameter>): any;
    visitTSParenthesizedType?(this: Context & M, path: NodePath<namedTypes.TSParenthesizedType>): any;
    visitTSFunctionType?(this: Context & M, path: NodePath<namedTypes.TSFunctionType>): any;
    visitTSConstructorType?(this: Context & M, path: NodePath<namedTypes.TSConstructorType>): any;
    visitTSDeclareFunction?(this: Context & M, path: NodePath<namedTypes.TSDeclareFunction>): any;
    visitTSDeclareMethod?(this: Context & M, path: NodePath<namedTypes.TSDeclareMethod>): any;
    visitTSMappedType?(this: Context & M, path: NodePath<namedTypes.TSMappedType>): any;
    visitTSTupleType?(this: Context & M, path: NodePath<namedTypes.TSTupleType>): any;
    visitTSNamedTupleMember?(this: Context & M, path: NodePath<namedTypes.TSNamedTupleMember>): any;
    visitTSRestType?(this: Context & M, path: NodePath<namedTypes.TSRestType>): any;
    visitTSOptionalType?(this: Context & M, path: NodePath<namedTypes.TSOptionalType>): any;
    visitTSIndexedAccessType?(this: Context & M, path: NodePath<namedTypes.TSIndexedAccessType>): any;
    visitTSTypeOperator?(this: Context & M, path: NodePath<namedTypes.TSTypeOperator>): any;
    visitTSIndexSignature?(this: Context & M, path: NodePath<namedTypes.TSIndexSignature>): any;
    visitTSPropertySignature?(this: Context & M, path: NodePath<namedTypes.TSPropertySignature>): any;
    visitTSMethodSignature?(this: Context & M, path: NodePath<namedTypes.TSMethodSignature>): any;
    visitTSTypePredicate?(this: Context & M, path: NodePath<namedTypes.TSTypePredicate>): any;
    visitTSCallSignatureDeclaration?(this: Context & M, path: NodePath<namedTypes.TSCallSignatureDeclaration>): any;
    visitTSConstructSignatureDeclaration?(this: Context & M, path: NodePath<namedTypes.TSConstructSignatureDeclaration>): any;
    visitTSEnumMember?(this: Context & M, path: NodePath<namedTypes.TSEnumMember>): any;
    visitTSTypeQuery?(this: Context & M, path: NodePath<namedTypes.TSTypeQuery>): any;
    visitTSImportType?(this: Context & M, path: NodePath<namedTypes.TSImportType>): any;
    visitTSTypeLiteral?(this: Context & M, path: NodePath<namedTypes.TSTypeLiteral>): any;
    visitTSTypeAssertion?(this: Context & M, path: NodePath<namedTypes.TSTypeAssertion>): any;
    visitTSInstantiationExpression?(this: Context & M, path: NodePath<namedTypes.TSInstantiationExpression>): any;
    visitTSEnumDeclaration?(this: Context & M, path: NodePath<namedTypes.TSEnumDeclaration>): any;
    visitTSTypeAliasDeclaration?(this: Context & M, path: NodePath<namedTypes.TSTypeAliasDeclaration>): any;
    visitTSModuleBlock?(this: Context & M, path: NodePath<namedTypes.TSModuleBlock>): any;
    visitTSModuleDeclaration?(this: Context & M, path: NodePath<namedTypes.TSModuleDeclaration>): any;
    visitTSImportEqualsDeclaration?(this: Context & M, path: NodePath<namedTypes.TSImportEqualsDeclaration>): any;
    visitTSExternalModuleReference?(this: Context & M, path: NodePath<namedTypes.TSExternalModuleReference>): any;
    visitTSExportAssignment?(this: Context & M, path: NodePath<namedTypes.TSExportAssignment>): any;
    visitTSNamespaceExportDeclaration?(this: Context & M, path: NodePath<namedTypes.TSNamespaceExportDeclaration>): any;
    visitTSInterfaceBody?(this: Context & M, path: NodePath<namedTypes.TSInterfaceBody>): any;
    visitTSInterfaceDeclaration?(this: Context & M, path: NodePath<namedTypes.TSInterfaceDeclaration>): any;
    visitTSParameterProperty?(this: Context & M, path: NodePath<namedTypes.TSParameterProperty>): any;
    visitTSEnumBody?(this: Context & M, path: NodePath<namedTypes.TSEnumBody>): any;
    visitTSInterfaceHeritage?(this: Context & M, path: NodePath<namedTypes.TSInterfaceHeritage>): any;
    visitTSClassImplements?(this: Context & M, path: NodePath<namedTypes.TSClassImplements>): any;
    visitTSTemplateLiteralType?(this: Context & M, path: NodePath<namedTypes.TSTemplateLiteralType>): any;
    visitTSEmptyBodyFunctionExpression?(this: Context & M, path: NodePath<namedTypes.TSEmptyBodyFunctionExpression>): any;
    visitTSAbstractMethodDefinition?(this: Context & M, path: NodePath<namedTypes.TSAbstractMethodDefinition>): any;
    visitTSAbstractPropertyDefinition?(this: Context & M, path: NodePath<namedTypes.TSAbstractPropertyDefinition>): any;
}

declare interface VisitorMethods {
    [visitorMethod: string]: (path: NodePath) => any;
}

/**
 * Attribute value nodes.
 * @public
 */
declare interface VLiteral extends HasParent {
    type: 'VLiteral';
    parent: VAttribute;
    value: string;
}

/**
 * The union type of any nodes.
 * @public
 */
declare type VNode = VAttribute | VDirective | VDirectiveKey | VDocumentFragment | VElement | VEndTag | VExpressionContainer | VIdentifier | VLiteral | VStartTag | VText | VGenericExpression;

/** @public */
declare interface VoidTypeAnnotationBuilder {
    (): namedTypes.VoidTypeAnnotation;
    from(params: {
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.VoidTypeAnnotation;
}

/** @public */
declare type VoidTypeAnnotationKind = namedTypes.VoidTypeAnnotation;

/**
 * The node of `v-on` directives.
 * @public
 */
declare interface VOnExpression extends HasParent {
    type: 'VOnExpression';
    parent: VExpressionContainer;
    body: StatementKind[];
}

/**
 * The node of `slot-scope` directives.
 * @public
 */
declare interface VSlotScopeExpression extends HasParent {
    type: 'VSlotScopeExpression';
    parent: VExpressionContainer;
    params: PatternKind[];
}

/**
 * Start tag nodes.
 * @public
 */
declare interface VStartTag extends HasParent, HasLeadingComment {
    type: 'VStartTag';
    parent: VElement;
    selfClosing: boolean;
    attributes: (VAttribute | VDirective)[];
}

/**
 * Style element nodes.
 * @public
 */
declare interface VStyleElement extends VElement {
    type: 'VElement';
    name: 'style';
    style: true;
    children: (VText | VExpressionContainer)[];
}

/**
 * Text nodes.
 * @public
 */
declare interface VText extends HasParent, HasLeadingComment {
    type: 'VText';
    parent: VDocumentFragment | VElement;
    value: string;
}

/**
 * ESTree Program type, with an additional property `isScriptSetup` that denotes whether the program
 * represents the contents of a \<script setup\> block in a Vue SFC
 *
 * @public
 */
export declare type VueProgram = namedTypes.Program & {
    /**
     * Whether this Program represents the contents of a \<script setup\>
     *
     * In a JS/TS file, this will always be false.
     */
    isScriptSetup: boolean;
};

/** @public */
declare interface WhileStatementBuilder {
    (test: Kinds.ExpressionKind, body: Kinds.StatementKind): namedTypes.WhileStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        test: Kinds.ExpressionKind;
    }): namedTypes.WhileStatement;
}

/** @public */
declare type WhileStatementKind = namedTypes.WhileStatement;

/** @public */
declare interface WithStatementBuilder {
    (object: Kinds.ExpressionKind, body: Kinds.StatementKind): namedTypes.WithStatement;
    from(params: {
        body: Kinds.StatementKind;
        comments?: Kinds.CommentKind[] | null;
        loc?: Kinds.SourceLocationKind | null;
        object: Kinds.ExpressionKind;
    }): namedTypes.WithStatement;
}

/** @public */
declare type WithStatementKind = namedTypes.WithStatement;

/** @public */
declare interface YieldExpressionBuilder {
    (argument: Kinds.ExpressionKind | null, delegate?: boolean): namedTypes.YieldExpression;
    from(params: {
        argument: Kinds.ExpressionKind | null;
        comments?: Kinds.CommentKind[] | null;
        delegate?: boolean;
        loc?: Kinds.SourceLocationKind | null;
    }): namedTypes.YieldExpression;
}

/** @public */
declare type YieldExpressionKind = namedTypes.YieldExpression;

export { }