import { TextRange } from '../common/textRange';
import { FStringEndToken, FStringMiddleToken, FStringStartToken, IdentifierToken, KeywordToken, KeywordType, NumberToken, OperatorType, StringToken, Token } from './tokenizerTypes';
export declare const enum ParseNodeType {
    Error = 0,// 0
    Argument = 1,
    Assert = 2,
    Assignment = 3,
    AssignmentExpression = 4,
    AugmentedAssignment = 5,
    Await = 6,
    BinaryOperation = 7,
    Break = 8,
    Call = 9,
    Class = 10,// 10
    Comprehension = 11,
    ComprehensionFor = 12,
    ComprehensionIf = 13,
    Constant = 14,
    Continue = 15,
    Decorator = 16,
    Del = 17,
    Dictionary = 18,
    DictionaryExpandEntry = 19,
    DictionaryKeyEntry = 20,// 20
    Ellipsis = 21,
    If = 22,
    Import = 23,
    ImportAs = 24,
    ImportFrom = 25,
    ImportFromAs = 26,
    Index = 27,
    Except = 28,
    For = 29,
    FormatString = 30,// 30
    Function = 31,
    Global = 32,
    Lambda = 33,
    List = 34,
    MemberAccess = 35,
    Module = 36,
    ModuleName = 37,
    Name = 38,
    Nonlocal = 39,
    Number = 40,// 40
    Parameter = 41,
    Pass = 42,
    Raise = 43,
    Return = 44,
    Set = 45,
    Slice = 46,
    StatementList = 47,
    StringList = 48,
    String = 49,
    Suite = 50,// 50
    Ternary = 51,
    Tuple = 52,
    Try = 53,
    TypeAnnotation = 54,
    UnaryOperation = 55,
    Unpack = 56,
    While = 57,
    With = 58,
    WithItem = 59,
    Yield = 60,// 60
    YieldFrom = 61,
    FunctionAnnotation = 62,
    Match = 63,
    Case = 64,
    PatternSequence = 65,
    PatternAs = 66,
    PatternLiteral = 67,
    PatternClass = 68,
    PatternCapture = 69,
    PatternMapping = 70,// 70
    PatternMappingKeyEntry = 71,
    PatternMappingExpandEntry = 72,
    PatternValue = 73,
    PatternClassArgument = 74,
    TypeParameter = 75,
    TypeParameterList = 76,
    TypeAlias = 77
}
export declare const enum ErrorExpressionCategory {
    MissingIn = 0,
    MissingElse = 1,
    MissingExpression = 2,
    MissingIndexOrSlice = 3,
    MissingDecoratorCallName = 4,
    MissingCallCloseParen = 5,
    MissingIndexCloseBracket = 6,
    MissingMemberAccessName = 7,
    MissingTupleCloseParen = 8,
    MissingListCloseBracket = 9,
    MissingFunctionParameterList = 10,
    MissingPattern = 11,
    MissingPatternSubject = 12,
    MissingDictValue = 13,
    MissingKeywordArgValue = 14,
    MaxDepthExceeded = 15
}
export interface ParseNodeBase<T extends ParseNodeType> {
    readonly nodeType: T;
    readonly start: number;
    readonly length: number;
    id: number;
    parent: ParseNode | undefined;
    a: object | undefined;
    d: object;
}
export declare function getNextNodeId(): number;
export declare function extendRange(node: ParseNodeBase<any>, newRange: TextRange): void;
export type ParseNodeArray = (ParseNode | undefined)[];
export interface ModuleNode extends ParseNodeBase<ParseNodeType.Module> {
    d: {
        statements: StatementNode[];
    };
}
export declare namespace ModuleNode {
    function create(range: TextRange): ModuleNode;
}
export interface SuiteNode extends ParseNodeBase<ParseNodeType.Suite> {
    d: {
        statements: StatementNode[];
        typeComment: StringToken | undefined;
    };
}
export declare namespace SuiteNode {
    function create(range: TextRange): SuiteNode;
}
export interface IfNode extends ParseNodeBase<ParseNodeType.If> {
    d: {
        firstToken: Token;
        testExpr: ExpressionNode;
        ifSuite: SuiteNode;
        elseSuite: SuiteNode | IfNode | undefined;
    };
}
export declare namespace IfNode {
    function create(ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
}
export interface WhileNode extends ParseNodeBase<ParseNodeType.While> {
    d: {
        firstToken: Token;
        testExpr: ExpressionNode;
        whileSuite: SuiteNode;
        elseSuite?: SuiteNode | undefined;
    };
}
export declare namespace WhileNode {
    function create(whileToken: Token, testExpr: ExpressionNode, whileSuite: SuiteNode): WhileNode;
}
export interface ForNode extends ParseNodeBase<ParseNodeType.For> {
    d: {
        firstToken: Token;
        isAsync?: boolean;
        asyncToken?: Token;
        targetExpr: ExpressionNode;
        iterableExpr: ExpressionNode;
        forSuite: SuiteNode;
        elseSuite?: SuiteNode | undefined;
        typeComment?: StringToken;
    };
}
export declare namespace ForNode {
    function create(forToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode, forSuite: SuiteNode): ForNode;
}
export type ComprehensionForIfNode = ComprehensionForNode | ComprehensionIfNode;
export interface ComprehensionForNode extends ParseNodeBase<ParseNodeType.ComprehensionFor> {
    d: {
        isAsync?: boolean;
        asyncToken?: Token;
        targetExpr: ExpressionNode;
        iterableExpr: ExpressionNode;
    };
}
export declare namespace ComprehensionForNode {
    function create(startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
}
export interface ComprehensionIfNode extends ParseNodeBase<ParseNodeType.ComprehensionIf> {
    d: {
        testExpr: ExpressionNode;
    };
}
export declare namespace ComprehensionIfNode {
    function create(ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
}
export interface TryNode extends ParseNodeBase<ParseNodeType.Try> {
    d: {
        firstToken: Token;
        trySuite: SuiteNode;
        exceptClauses: ExceptNode[];
        elseSuite?: SuiteNode | undefined;
        finallySuite?: SuiteNode | undefined;
    };
}
export declare namespace TryNode {
    function create(tryToken: Token, trySuite: SuiteNode): TryNode;
}
export interface ExceptNode extends ParseNodeBase<ParseNodeType.Except> {
    d: {
        typeExpr?: ExpressionNode | undefined;
        name?: NameNode | undefined;
        exceptSuite: SuiteNode;
        isExceptGroup: boolean;
        exceptToken: Token;
    };
}
export declare namespace ExceptNode {
    function create(exceptToken: Token, exceptSuite: SuiteNode, isExceptGroup: boolean): ExceptNode;
}
export interface FunctionNode extends ParseNodeBase<ParseNodeType.Function> {
    d: {
        firstToken: Token;
        decorators: DecoratorNode[];
        isAsync: boolean;
        name: NameNode;
        typeParams: TypeParameterListNode | undefined;
        params: ParameterNode[];
        returnAnnotation: ExpressionNode | undefined;
        funcAnnotationComment: FunctionAnnotationNode | undefined;
        suite: SuiteNode;
    };
}
export declare namespace FunctionNode {
    function create(defToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): FunctionNode;
}
export declare const enum ParamCategory {
    Simple = 0,
    ArgsList = 1,
    KwargsDict = 2
}
export interface ParameterNode extends ParseNodeBase<ParseNodeType.Parameter> {
    d: {
        category: ParamCategory;
        name: NameNode | undefined;
        annotation: ExpressionNode | undefined;
        annotationComment: ExpressionNode | undefined;
        defaultValue: ExpressionNode | undefined;
    };
}
export declare namespace ParameterNode {
    function create(startToken: Token, paramCategory: ParamCategory): ParameterNode;
}
export interface ClassNode extends ParseNodeBase<ParseNodeType.Class> {
    d: {
        firstToken: Token;
        decorators: DecoratorNode[];
        name: NameNode;
        typeParams: TypeParameterListNode | undefined;
        arguments: ArgumentNode[];
        suite: SuiteNode;
    };
}
export declare namespace ClassNode {
    function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): ClassNode;
    function createDummyForDecorators(decorators: DecoratorNode[]): ClassNode;
}
export interface WithNode extends ParseNodeBase<ParseNodeType.With> {
    d: {
        firstToken: Token;
        isAsync?: boolean;
        asyncToken?: Token;
        withItems: WithItemNode[];
        suite: SuiteNode;
        typeComment?: StringToken;
    };
}
export declare namespace WithNode {
    function create(withToken: Token, suite: SuiteNode): WithNode;
}
export interface WithItemNode extends ParseNodeBase<ParseNodeType.WithItem> {
    d: {
        expr: ExpressionNode;
        target?: ExpressionNode | undefined;
    };
}
export declare namespace WithItemNode {
    function create(expr: ExpressionNode): WithItemNode;
}
export interface DecoratorNode extends ParseNodeBase<ParseNodeType.Decorator> {
    d: {
        expr: ExpressionNode;
    };
}
export declare namespace DecoratorNode {
    function create(atToken: Token, expr: ExpressionNode): DecoratorNode;
}
export interface StatementListNode extends ParseNodeBase<ParseNodeType.StatementList> {
    d: {
        firstToken: Token;
        statements: ParseNode[];
    };
}
export declare namespace StatementListNode {
    function create(atToken: Token): StatementListNode;
}
export type StatementNode = IfNode | WhileNode | ForNode | TryNode | FunctionNode | ClassNode | WithNode | StatementListNode | MatchNode | TypeAliasNode | ErrorNode;
export type SmallStatementNode = ExpressionNode | DelNode | PassNode | ImportNode | GlobalNode | NonlocalNode | AssertNode;
export type ExpressionNode = ErrorNode | UnaryOperationNode | BinaryOperationNode | AssignmentNode | TypeAnnotationNode | AssignmentExpressionNode | AugmentedAssignmentNode | AwaitNode | TernaryNode | UnpackNode | TupleNode | CallNode | ComprehensionNode | IndexNode | SliceNode | YieldNode | YieldFromNode | MemberAccessNode | LambdaNode | NameNode | ConstantNode | EllipsisNode | NumberNode | StringNode | FormatStringNode | StringListNode | DictionaryNode | ListNode | SetNode;
export declare function isExpressionNode(node: ParseNode): node is ExpressionNode;
export interface ErrorNode extends ParseNodeBase<ParseNodeType.Error> {
    d: {
        readonly category: ErrorExpressionCategory;
        readonly child: ExpressionNode | undefined;
        readonly decorators?: DecoratorNode[] | undefined;
    };
}
export declare namespace ErrorNode {
    function create(initialRange: TextRange, category: ErrorExpressionCategory, child?: ExpressionNode, decorators?: DecoratorNode[]): ErrorNode;
}
export interface UnaryOperationNode extends ParseNodeBase<ParseNodeType.UnaryOperation> {
    d: {
        expr: ExpressionNode;
        operatorToken: Token;
        operator: OperatorType;
        hasParens: boolean;
    };
}
export declare namespace UnaryOperationNode {
    function create(operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
}
export interface BinaryOperationNode extends ParseNodeBase<ParseNodeType.BinaryOperation> {
    d: {
        leftExpr: ExpressionNode;
        operatorToken: Token;
        operator: OperatorType;
        rightExpr: ExpressionNode;
        hasParens: boolean;
    };
}
export declare namespace BinaryOperationNode {
    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
}
export interface AssignmentExpressionNode extends ParseNodeBase<ParseNodeType.AssignmentExpression> {
    d: {
        name: NameNode;
        walrusToken: Token;
        rightExpr: ExpressionNode;
        hasParens: boolean;
    };
}
export declare namespace AssignmentExpressionNode {
    function create(name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
}
export interface AssignmentNode extends ParseNodeBase<ParseNodeType.Assignment> {
    d: {
        leftExpr: ExpressionNode;
        rightExpr: ExpressionNode;
        annotationComment?: ExpressionNode | undefined;
        chainedAnnotationComment?: ExpressionNode | undefined;
    };
}
export declare namespace AssignmentNode {
    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
}
export declare enum TypeParamKind {
    TypeVar = 0,
    TypeVarTuple = 1,
    ParamSpec = 2
}
export interface TypeParameterNode extends ParseNodeBase<ParseNodeType.TypeParameter> {
    d: {
        name: NameNode;
        typeParamKind: TypeParamKind;
        boundExpr?: ExpressionNode;
        defaultExpr?: ExpressionNode;
    };
}
export declare namespace TypeParameterNode {
    function create(name: NameNode, typeParamKind: TypeParamKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
}
export interface TypeParameterListNode extends ParseNodeBase<ParseNodeType.TypeParameterList> {
    d: {
        params: TypeParameterNode[];
    };
}
export declare namespace TypeParameterListNode {
    function create(startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
}
export interface TypeAliasNode extends ParseNodeBase<ParseNodeType.TypeAlias> {
    d: {
        firstToken: Token;
        name: NameNode;
        typeParams?: TypeParameterListNode;
        expr: ExpressionNode;
    };
}
export declare namespace TypeAliasNode {
    function create(typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
}
export interface TypeAnnotationNode extends ParseNodeBase<ParseNodeType.TypeAnnotation> {
    d: {
        valueExpr: ExpressionNode;
        annotation: ExpressionNode;
    };
}
export declare namespace TypeAnnotationNode {
    function create(valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
}
export interface FunctionAnnotationNode extends ParseNodeBase<ParseNodeType.FunctionAnnotation> {
    d: {
        isEllipsis: boolean;
        paramAnnotations: ExpressionNode[];
        returnAnnotation: ExpressionNode;
    };
}
export declare namespace FunctionAnnotationNode {
    function create(openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
}
export interface AugmentedAssignmentNode extends ParseNodeBase<ParseNodeType.AugmentedAssignment> {
    d: {
        leftExpr: ExpressionNode;
        operator: OperatorType;
        rightExpr: ExpressionNode;
        destExpr: ExpressionNode;
    };
}
export declare namespace AugmentedAssignmentNode {
    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
}
export interface AwaitNode extends ParseNodeBase<ParseNodeType.Await> {
    d: {
        expr: ExpressionNode;
        awaitToken: Token;
        hasParens: boolean;
    };
}
export declare namespace AwaitNode {
    function create(awaitToken: Token, expr: ExpressionNode): AwaitNode;
}
export interface TernaryNode extends ParseNodeBase<ParseNodeType.Ternary> {
    d: {
        ifExpr: ExpressionNode;
        testExpr: ExpressionNode;
        elseExpr: ExpressionNode;
    };
}
export declare namespace TernaryNode {
    function create(ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
}
export interface UnpackNode extends ParseNodeBase<ParseNodeType.Unpack> {
    d: {
        expr: ExpressionNode;
        starToken: Token;
    };
}
export declare namespace UnpackNode {
    function create(starToken: Token, expr: ExpressionNode): UnpackNode;
}
export interface TupleNode extends ParseNodeBase<ParseNodeType.Tuple> {
    d: {
        items: ExpressionNode[];
        hasParens: boolean;
    };
}
export declare namespace TupleNode {
    function create(range: TextRange, hasParens: boolean): TupleNode;
}
export interface CallNode extends ParseNodeBase<ParseNodeType.Call> {
    d: {
        leftExpr: ExpressionNode;
        args: ArgumentNode[];
        trailingComma: boolean;
    };
}
export declare namespace CallNode {
    function create(leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
}
export interface ComprehensionNode extends ParseNodeBase<ParseNodeType.Comprehension> {
    d: {
        expr: ParseNode;
        forIfNodes: ComprehensionForIfNode[];
        isGenerator: boolean;
        hasParens: boolean;
    };
}
export declare namespace ComprehensionNode {
    function create(expr: ParseNode, isGenerator: boolean): ComprehensionNode;
}
export interface IndexNode extends ParseNodeBase<ParseNodeType.Index> {
    d: {
        leftExpr: ExpressionNode;
        items: ArgumentNode[];
        trailingComma: boolean;
    };
}
export declare namespace IndexNode {
    function create(leftExpr: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
}
export interface SliceNode extends ParseNodeBase<ParseNodeType.Slice> {
    d: {
        startValue?: ExpressionNode | undefined;
        endValue?: ExpressionNode | undefined;
        stepValue?: ExpressionNode | undefined;
    };
}
export declare namespace SliceNode {
    function create(range: TextRange): SliceNode;
}
export interface YieldNode extends ParseNodeBase<ParseNodeType.Yield> {
    d: {
        expr?: ExpressionNode | undefined;
    };
}
export declare namespace YieldNode {
    function create(yieldToken: Token, expr?: ExpressionNode): YieldNode;
}
export interface YieldFromNode extends ParseNodeBase<ParseNodeType.YieldFrom> {
    d: {
        expr: ExpressionNode;
    };
}
export declare namespace YieldFromNode {
    function create(yieldToken: Token, expr: ExpressionNode): YieldFromNode;
}
export interface MemberAccessNode extends ParseNodeBase<ParseNodeType.MemberAccess> {
    d: {
        leftExpr: ExpressionNode;
        member: NameNode;
    };
}
export declare namespace MemberAccessNode {
    function create(leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
}
export interface LambdaNode extends ParseNodeBase<ParseNodeType.Lambda> {
    d: {
        params: ParameterNode[];
        expr: ExpressionNode;
    };
}
export declare namespace LambdaNode {
    function create(lambdaToken: Token, expr: ExpressionNode): LambdaNode;
}
export interface NameNode extends ParseNodeBase<ParseNodeType.Name> {
    d: {
        token: IdentifierToken;
        value: string;
    };
}
export declare namespace NameNode {
    function create(nameToken: IdentifierToken): NameNode;
}
export interface ConstantNode extends ParseNodeBase<ParseNodeType.Constant> {
    d: {
        constType: KeywordType;
    };
}
export declare namespace ConstantNode {
    function create(token: KeywordToken): ConstantNode;
}
export interface EllipsisNode extends ParseNodeBase<ParseNodeType.Ellipsis> {
}
export declare namespace EllipsisNode {
    function create(range: TextRange): EllipsisNode;
}
export interface NumberNode extends ParseNodeBase<ParseNodeType.Number> {
    d: {
        value: number | bigint;
        isInteger: boolean;
        isImaginary: boolean;
    };
}
export declare namespace NumberNode {
    function create(token: NumberToken): NumberNode;
}
export interface StringNode extends ParseNodeBase<ParseNodeType.String> {
    d: {
        token: StringToken;
        value: string;
    };
}
export declare namespace StringNode {
    function create(token: StringToken, value: string): StringNode;
}
export interface FormatStringNode extends ParseNodeBase<ParseNodeType.FormatString> {
    d: {
        token: FStringStartToken;
        middleTokens: FStringMiddleToken[];
        fieldExprs: ExpressionNode[];
        formatExprs: ExpressionNode[];
        value: '';
    };
}
export declare namespace FormatStringNode {
    function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
}
export interface StringListNode extends ParseNodeBase<ParseNodeType.StringList> {
    d: {
        strings: (StringNode | FormatStringNode)[];
        annotation: ExpressionNode | undefined;
        hasParens: boolean;
    };
}
export declare namespace StringListNode {
    function create(strings: (StringNode | FormatStringNode)[]): StringListNode;
}
export interface DictionaryNode extends ParseNodeBase<ParseNodeType.Dictionary> {
    d: {
        items: DictionaryEntryNode[];
        trailingCommaToken: Token | undefined;
    };
}
export declare namespace DictionaryNode {
    function create(range: TextRange): DictionaryNode;
}
export interface DictionaryKeyEntryNode extends ParseNodeBase<ParseNodeType.DictionaryKeyEntry> {
    d: {
        keyExpr: ExpressionNode;
        valueExpr: ExpressionNode;
    };
}
export declare namespace DictionaryKeyEntryNode {
    function create(keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
}
export interface DictionaryExpandEntryNode extends ParseNodeBase<ParseNodeType.DictionaryExpandEntry> {
    d: {
        expr: ExpressionNode;
    };
}
export declare namespace DictionaryExpandEntryNode {
    function create(expr: ExpressionNode): DictionaryExpandEntryNode;
}
export type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ComprehensionNode;
export interface SetNode extends ParseNodeBase<ParseNodeType.Set> {
    d: {
        items: ExpressionNode[];
    };
}
export declare namespace SetNode {
    function create(range: TextRange): SetNode;
}
export interface ListNode extends ParseNodeBase<ParseNodeType.List> {
    d: {
        items: ExpressionNode[];
    };
}
export declare namespace ListNode {
    function create(range: TextRange): ListNode;
}
export declare const enum ArgCategory {
    Simple = 0,
    UnpackedList = 1,
    UnpackedDictionary = 2
}
export interface ArgumentNode extends ParseNodeBase<ParseNodeType.Argument> {
    d: {
        argCategory: ArgCategory;
        name: NameNode | undefined;
        valueExpr: ExpressionNode;
    };
}
export declare namespace ArgumentNode {
    function create(startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgCategory): ArgumentNode;
}
export interface DelNode extends ParseNodeBase<ParseNodeType.Del> {
    d: {
        targets: ExpressionNode[];
    };
}
export declare namespace DelNode {
    function create(delToken: Token): DelNode;
}
export interface PassNode extends ParseNodeBase<ParseNodeType.Pass> {
}
export declare namespace PassNode {
    function create(passToken: TextRange): PassNode;
}
export interface ImportNode extends ParseNodeBase<ParseNodeType.Import> {
    d: {
        list: ImportAsNode[];
    };
}
export declare namespace ImportNode {
    function create(importToken: TextRange): ImportNode;
}
export interface ModuleNameNode extends ParseNodeBase<ParseNodeType.ModuleName> {
    d: {
        leadingDots: number;
        nameParts: NameNode[];
        hasTrailingDot?: boolean;
    };
}
export declare namespace ModuleNameNode {
    function create(range: TextRange): ModuleNameNode;
}
export interface ImportAsNode extends ParseNodeBase<ParseNodeType.ImportAs> {
    d: {
        module: ModuleNameNode;
        alias?: NameNode | undefined;
    };
}
export declare namespace ImportAsNode {
    function create(module: ModuleNameNode): ImportAsNode;
}
export interface ImportFromNode extends ParseNodeBase<ParseNodeType.ImportFrom> {
    d: {
        module: ModuleNameNode;
        imports: ImportFromAsNode[];
        isWildcardImport: boolean;
        usesParens: boolean;
        wildcardToken?: Token;
        missingImport?: boolean;
    };
}
export declare namespace ImportFromNode {
    function create(fromToken: Token, module: ModuleNameNode): ImportFromNode;
}
export interface ImportFromAsNode extends ParseNodeBase<ParseNodeType.ImportFromAs> {
    d: {
        name: NameNode;
        alias?: NameNode | undefined;
    };
}
export declare namespace ImportFromAsNode {
    function create(name: NameNode): ImportFromAsNode;
}
export interface GlobalNode extends ParseNodeBase<ParseNodeType.Global> {
    d: {
        targets: NameNode[];
    };
}
export declare namespace GlobalNode {
    function create(range: TextRange): GlobalNode;
}
export interface NonlocalNode extends ParseNodeBase<ParseNodeType.Nonlocal> {
    d: {
        targets: NameNode[];
    };
}
export declare namespace NonlocalNode {
    function create(range: TextRange): NonlocalNode;
}
export interface AssertNode extends ParseNodeBase<ParseNodeType.Assert> {
    d: {
        testExpr: ExpressionNode;
        exceptionExpr?: ExpressionNode | undefined;
    };
}
export declare namespace AssertNode {
    function create(assertToken: Token, testExpr: ExpressionNode): AssertNode;
}
export interface BreakNode extends ParseNodeBase<ParseNodeType.Break> {
}
export declare namespace BreakNode {
    function create(range: TextRange): BreakNode;
}
export interface ContinueNode extends ParseNodeBase<ParseNodeType.Continue> {
}
export declare namespace ContinueNode {
    function create(range: TextRange): ContinueNode;
}
export interface ReturnNode extends ParseNodeBase<ParseNodeType.Return> {
    d: {
        expr?: ExpressionNode | undefined;
    };
}
export declare namespace ReturnNode {
    function create(range: TextRange): ReturnNode;
}
export interface RaiseNode extends ParseNodeBase<ParseNodeType.Raise> {
    d: {
        expr?: ExpressionNode | undefined;
        fromExpr?: ExpressionNode | undefined;
    };
}
export declare namespace RaiseNode {
    function create(range: TextRange): RaiseNode;
}
export interface MatchNode extends ParseNodeBase<ParseNodeType.Match> {
    d: {
        firstToken: Token;
        expr: ExpressionNode;
        cases: CaseNode[];
    };
}
export declare namespace MatchNode {
    function create(matchToken: Token, expr: ExpressionNode): MatchNode;
}
export interface CaseNode extends ParseNodeBase<ParseNodeType.Case> {
    d: {
        pattern: PatternAtomNode;
        isIrrefutable: boolean;
        guardExpr?: ExpressionNode | undefined;
        suite: SuiteNode;
    };
}
export declare namespace CaseNode {
    function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
}
export interface PatternSequenceNode extends ParseNodeBase<ParseNodeType.PatternSequence> {
    d: {
        entries: PatternAsNode[];
        starEntryIndex: number | undefined;
    };
}
export declare namespace PatternSequenceNode {
    function create(firstToken: TextRange, entries: PatternAsNode[]): PatternSequenceNode;
}
export interface PatternAsNode extends ParseNodeBase<ParseNodeType.PatternAs> {
    d: {
        orPatterns: PatternAtomNode[];
        target?: NameNode | undefined;
    };
}
export declare namespace PatternAsNode {
    function create(orPatterns: PatternAtomNode[], target?: NameNode): PatternAsNode;
}
export interface PatternLiteralNode extends ParseNodeBase<ParseNodeType.PatternLiteral> {
    d: {
        expr: ExpressionNode;
    };
}
export declare namespace PatternLiteralNode {
    function create(expr: ExpressionNode): PatternLiteralNode;
}
export interface PatternClassNode extends ParseNodeBase<ParseNodeType.PatternClass> {
    d: {
        className: NameNode | MemberAccessNode;
        args: PatternClassArgumentNode[];
    };
}
export declare namespace PatternClassNode {
    function create(className: NameNode | MemberAccessNode, args: PatternClassArgumentNode[]): PatternClassNode;
}
export interface PatternClassArgumentNode extends ParseNodeBase<ParseNodeType.PatternClassArgument> {
    d: {
        name?: NameNode | undefined;
        pattern: PatternAsNode;
    };
}
export declare namespace PatternClassArgumentNode {
    function create(pattern: PatternAsNode, name?: NameNode): PatternClassArgumentNode;
}
export interface PatternCaptureNode extends ParseNodeBase<ParseNodeType.PatternCapture> {
    d: {
        target: NameNode;
        isStar: boolean;
        isWildcard: boolean;
    };
}
export declare namespace PatternCaptureNode {
    function create(target: NameNode, starToken?: TextRange): PatternCaptureNode;
}
export interface PatternMappingNode extends ParseNodeBase<ParseNodeType.PatternMapping> {
    d: {
        entries: PatternMappingEntryNode[];
    };
}
export declare namespace PatternMappingNode {
    function create(startToken: TextRange, entries: PatternMappingEntryNode[]): PatternMappingNode;
}
export type PatternMappingEntryNode = PatternMappingKeyEntryNode | PatternMappingExpandEntryNode;
export interface PatternMappingKeyEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingKeyEntry> {
    d: {
        keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode;
        valuePattern: PatternAsNode | ErrorNode;
    };
}
export declare namespace PatternMappingKeyEntryNode {
    function create(keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode, valuePattern: PatternAsNode | ErrorNode): PatternMappingKeyEntryNode;
}
export interface PatternMappingExpandEntryNode extends ParseNodeBase<ParseNodeType.PatternMappingExpandEntry> {
    d: {
        target: NameNode;
    };
}
export declare namespace PatternMappingExpandEntryNode {
    function create(starStarToken: TextRange, target: NameNode): PatternMappingExpandEntryNode;
}
export interface PatternValueNode extends ParseNodeBase<ParseNodeType.PatternValue> {
    d: {
        expr: MemberAccessNode;
    };
}
export declare namespace PatternValueNode {
    function create(expr: MemberAccessNode): PatternValueNode;
}
export type PatternAtomNode = PatternSequenceNode | PatternLiteralNode | PatternClassNode | PatternAsNode | PatternCaptureNode | PatternMappingNode | PatternValueNode | ErrorNode;
export type ParseNode = ErrorNode | ArgumentNode | AssertNode | AssignmentExpressionNode | AssignmentNode | AugmentedAssignmentNode | AwaitNode | BinaryOperationNode | BreakNode | CallNode | CaseNode | ClassNode | ComprehensionNode | ComprehensionForNode | ComprehensionIfNode | ConstantNode | ContinueNode | DecoratorNode | DelNode | DictionaryNode | DictionaryExpandEntryNode | DictionaryKeyEntryNode | EllipsisNode | IfNode | ImportNode | ImportAsNode | ImportFromNode | ImportFromAsNode | IndexNode | ExceptNode | ForNode | FormatStringNode | FunctionNode | FunctionAnnotationNode | GlobalNode | LambdaNode | ListNode | MatchNode | MemberAccessNode | ModuleNameNode | ModuleNode | NameNode | NonlocalNode | NumberNode | ParameterNode | PassNode | PatternAsNode | PatternClassNode | PatternClassArgumentNode | PatternCaptureNode | PatternLiteralNode | PatternMappingExpandEntryNode | PatternMappingKeyEntryNode | PatternMappingNode | PatternSequenceNode | PatternValueNode | RaiseNode | ReturnNode | SetNode | SliceNode | StatementListNode | StringListNode | StringNode | SuiteNode | TernaryNode | TupleNode | TryNode | TypeAliasNode | TypeAnnotationNode | TypeParameterNode | TypeParameterListNode | UnaryOperationNode | UnpackNode | WhileNode | WithNode | WithItemNode | YieldNode | YieldFromNode;
export type EvaluationScopeNode = LambdaNode | FunctionNode | ModuleNode | ClassNode | ComprehensionNode | TypeParameterListNode;
export type ExecutionScopeNode = LambdaNode | FunctionNode | ModuleNode | TypeParameterListNode;
export type TypeParameterScopeNode = FunctionNode | ClassNode | TypeAliasNode;