@zzzen/pyright-internal 1.1.254

package/dist/parser/parseNodes.d.ts

@@ -0,0 +1,750 @@
+import { TextRange } from '../common/textRange';
+import { IdentifierToken, KeywordToken, KeywordType, NumberToken, OperatorType, StringToken, Token } from './tokenizerTypes';
+export declare const enum ParseNodeType {
+    Error = 0,
+    Argument = 1,
+    Assert = 2,
+    Assignment = 3,
+    AssignmentExpression = 4,
+    AugmentedAssignment = 5,
+    Await = 6,
+    BinaryOperation = 7,
+    Break = 8,
+    Call = 9,
+    Class = 10,
+    Constant = 11,
+    Continue = 12,
+    Decorator = 13,
+    Del = 14,
+    Dictionary = 15,
+    DictionaryExpandEntry = 16,
+    DictionaryKeyEntry = 17,
+    Ellipsis = 18,
+    If = 19,
+    Import = 20,
+    ImportAs = 21,
+    ImportFrom = 22,
+    ImportFromAs = 23,
+    Index = 24,
+    Except = 25,
+    For = 26,
+    FormatString = 27,
+    Function = 28,
+    Global = 29,
+    Lambda = 30,
+    List = 31,
+    ListComprehension = 32,
+    ListComprehensionFor = 33,
+    ListComprehensionIf = 34,
+    MemberAccess = 35,
+    Module = 36,
+    ModuleName = 37,
+    Name = 38,
+    Nonlocal = 39,
+    Number = 40,
+    Parameter = 41,
+    Pass = 42,
+    Raise = 43,
+    Return = 44,
+    Set = 45,
+    Slice = 46,
+    StatementList = 47,
+    StringList = 48,
+    String = 49,
+    Suite = 50,
+    Ternary = 51,
+    Tuple = 52,
+    Try = 53,
+    TypeAnnotation = 54,
+    UnaryOperation = 55,
+    Unpack = 56,
+    While = 57,
+    With = 58,
+    WithItem = 59,
+    Yield = 60,
+    YieldFrom = 61,
+    FunctionAnnotation = 62,
+    Match = 63,
+    Case = 64,
+    PatternSequence = 65,
+    PatternAs = 66,
+    PatternLiteral = 67,
+    PatternClass = 68,
+    PatternCapture = 69,
+    PatternMapping = 70,
+    PatternMappingKeyEntry = 71,
+    PatternMappingExpandEntry = 72,
+    PatternValue = 73,
+    PatternClassArgument = 74
+}
+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,
+    MaxDepthExceeded = 14
+}
+export interface ParseNodeBase extends TextRange {
+    readonly nodeType: ParseNodeType;
+    id: number;
+    parent?: ParseNode | undefined;
+    maxChildDepth?: number;
+}
+export declare function getNextNodeId(): number;
+export declare function extendRange(node: ParseNodeBase, newRange: TextRange): void;
+export declare type ParseNodeArray = (ParseNode | undefined)[];
+export interface ModuleNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Module;
+    statements: StatementNode[];
+}
+export declare namespace ModuleNode {
+    function create(range: TextRange): ModuleNode;
+}
+export interface SuiteNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Suite;
+    statements: StatementNode[];
+}
+export declare namespace SuiteNode {
+    function create(range: TextRange): SuiteNode;
+}
+export interface IfNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.If;
+    testExpression: ExpressionNode;
+    ifSuite: SuiteNode;
+    elseSuite?: SuiteNode | IfNode | undefined;
+}
+export declare namespace IfNode {
+    function create(ifOrElifToken: Token, testExpression: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
+}
+export interface WhileNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.While;
+    testExpression: ExpressionNode;
+    whileSuite: SuiteNode;
+    elseSuite?: SuiteNode | undefined;
+}
+export declare namespace WhileNode {
+    function create(whileToken: Token, testExpression: ExpressionNode, whileSuite: SuiteNode): WhileNode;
+}
+export interface ForNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.For;
+    isAsync?: boolean;
+    asyncToken?: Token;
+    targetExpression: ExpressionNode;
+    iterableExpression: ExpressionNode;
+    forSuite: SuiteNode;
+    elseSuite?: SuiteNode | undefined;
+}
+export declare namespace ForNode {
+    function create(forToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode, forSuite: SuiteNode): ForNode;
+}
+export declare type ListComprehensionForIfNode = ListComprehensionForNode | ListComprehensionIfNode;
+export interface ListComprehensionForNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ListComprehensionFor;
+    isAsync?: boolean;
+    asyncToken?: Token;
+    targetExpression: ExpressionNode;
+    iterableExpression: ExpressionNode;
+}
+export declare namespace ListComprehensionForNode {
+    function create(startToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode): ListComprehensionForNode;
+}
+export interface ListComprehensionIfNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ListComprehensionIf;
+    testExpression: ExpressionNode;
+}
+export declare namespace ListComprehensionIfNode {
+    function create(ifToken: Token, testExpression: ExpressionNode): ListComprehensionIfNode;
+}
+export interface TryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Try;
+    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 {
+    readonly nodeType: ParseNodeType.Except;
+    typeExpression?: ExpressionNode | undefined;
+    name?: NameNode | undefined;
+    exceptSuite: SuiteNode;
+    isExceptGroup: boolean;
+}
+export declare namespace ExceptNode {
+    function create(exceptToken: Token, exceptSuite: SuiteNode, isExceptGroup: boolean): ExceptNode;
+}
+export interface FunctionNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Function;
+    decorators: DecoratorNode[];
+    isAsync?: boolean;
+    name: NameNode;
+    parameters: ParameterNode[];
+    returnTypeAnnotation?: ExpressionNode | undefined;
+    functionAnnotationComment?: FunctionAnnotationNode | undefined;
+    suite: SuiteNode;
+}
+export declare namespace FunctionNode {
+    function create(defToken: Token, name: NameNode, suite: SuiteNode): FunctionNode;
+}
+export declare const enum ParameterCategory {
+    Simple = 0,
+    VarArgList = 1,
+    VarArgDictionary = 2
+}
+export interface ParameterNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Parameter;
+    category: ParameterCategory;
+    name?: NameNode | undefined;
+    typeAnnotation?: ExpressionNode | undefined;
+    typeAnnotationComment?: ExpressionNode | undefined;
+    defaultValue?: ExpressionNode | undefined;
+}
+export declare namespace ParameterNode {
+    function create(startToken: Token, paramCategory: ParameterCategory): ParameterNode;
+}
+export interface ClassNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Class;
+    decorators: DecoratorNode[];
+    name: NameNode;
+    arguments: ArgumentNode[];
+    suite: SuiteNode;
+}
+export declare namespace ClassNode {
+    function create(classToken: Token, name: NameNode, suite: SuiteNode): ClassNode;
+    function createDummyForDecorators(decorators: DecoratorNode[]): ClassNode;
+}
+export interface WithNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.With;
+    isAsync?: boolean;
+    asyncToken?: Token;
+    withItems: WithItemNode[];
+    suite: SuiteNode;
+}
+export declare namespace WithNode {
+    function create(withToken: Token, suite: SuiteNode): WithNode;
+}
+export interface WithItemNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.WithItem;
+    expression: ExpressionNode;
+    target?: ExpressionNode | undefined;
+}
+export declare namespace WithItemNode {
+    function create(expression: ExpressionNode): WithItemNode;
+}
+export interface DecoratorNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Decorator;
+    expression: ExpressionNode;
+}
+export declare namespace DecoratorNode {
+    function create(atToken: Token, expression: ExpressionNode): DecoratorNode;
+}
+export interface StatementListNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.StatementList;
+    statements: ParseNode[];
+}
+export declare namespace StatementListNode {
+    function create(atToken: Token): StatementListNode;
+}
+export declare type StatementNode = IfNode | WhileNode | ForNode | TryNode | FunctionNode | ClassNode | WithNode | StatementListNode | MatchNode | ErrorNode;
+export declare type SmallStatementNode = ExpressionNode | DelNode | PassNode | ImportNode | GlobalNode | NonlocalNode | AssertNode;
+export declare type ExpressionNode = ErrorNode | UnaryOperationNode | BinaryOperationNode | AssignmentNode | TypeAnnotationNode | AssignmentExpressionNode | AugmentedAssignmentNode | AwaitNode | TernaryNode | UnpackNode | TupleNode | CallNode | ListComprehensionNode | 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 {
+    readonly nodeType: ParseNodeType.Error;
+    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 {
+    readonly nodeType: ParseNodeType.UnaryOperation;
+    expression: ExpressionNode;
+    operatorToken: Token;
+    operator: OperatorType;
+}
+export declare namespace UnaryOperationNode {
+    function create(operatorToken: Token, expression: ExpressionNode, operator: OperatorType): UnaryOperationNode;
+}
+export interface BinaryOperationNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.BinaryOperation;
+    leftExpression: ExpressionNode;
+    operatorToken: Token;
+    operator: OperatorType;
+    rightExpression: ExpressionNode;
+    parenthesized?: boolean;
+}
+export declare namespace BinaryOperationNode {
+    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
+}
+export interface AssignmentExpressionNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.AssignmentExpression;
+    name: NameNode;
+    rightExpression: ExpressionNode;
+}
+export declare namespace AssignmentExpressionNode {
+    function create(name: NameNode, rightExpression: ExpressionNode): AssignmentExpressionNode;
+}
+export interface AssignmentNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Assignment;
+    leftExpression: ExpressionNode;
+    rightExpression: ExpressionNode;
+    typeAnnotationComment?: ExpressionNode | undefined;
+}
+export declare namespace AssignmentNode {
+    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode): AssignmentNode;
+}
+export interface TypeAnnotationNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.TypeAnnotation;
+    valueExpression: ExpressionNode;
+    typeAnnotation: ExpressionNode;
+}
+export declare namespace TypeAnnotationNode {
+    function create(valueExpression: ExpressionNode, typeAnnotation: ExpressionNode): TypeAnnotationNode;
+}
+export interface FunctionAnnotationNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.FunctionAnnotation;
+    isParamListEllipsis: boolean;
+    paramTypeAnnotations: ExpressionNode[];
+    returnTypeAnnotation: ExpressionNode;
+}
+export declare namespace FunctionAnnotationNode {
+    function create(openParenToken: Token, isParamListEllipsis: boolean, paramTypeAnnotations: ExpressionNode[], returnTypeAnnotation: ExpressionNode): FunctionAnnotationNode;
+}
+export interface AugmentedAssignmentNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.AugmentedAssignment;
+    leftExpression: ExpressionNode;
+    operator: OperatorType;
+    rightExpression: ExpressionNode;
+    destExpression: ExpressionNode;
+}
+export declare namespace AugmentedAssignmentNode {
+    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operator: OperatorType, destExpression: ExpressionNode): AugmentedAssignmentNode;
+}
+export interface AwaitNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Await;
+    expression: ExpressionNode;
+}
+export declare namespace AwaitNode {
+    function create(awaitToken: Token, expression: ExpressionNode): AwaitNode;
+}
+export interface TernaryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Ternary;
+    ifExpression: ExpressionNode;
+    testExpression: ExpressionNode;
+    elseExpression: ExpressionNode;
+}
+export declare namespace TernaryNode {
+    function create(ifExpression: ExpressionNode, testExpression: ExpressionNode, elseExpression: ExpressionNode): TernaryNode;
+}
+export interface UnpackNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Unpack;
+    expression: ExpressionNode;
+}
+export declare namespace UnpackNode {
+    function create(starToken: Token, expression: ExpressionNode): UnpackNode;
+}
+export interface TupleNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Tuple;
+    expressions: ExpressionNode[];
+    enclosedInParens: boolean;
+}
+export declare namespace TupleNode {
+    function create(range: TextRange, enclosedInParens: boolean): TupleNode;
+}
+export interface CallNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Call;
+    leftExpression: ExpressionNode;
+    arguments: ArgumentNode[];
+    trailingComma: boolean;
+}
+export declare namespace CallNode {
+    function create(leftExpression: ExpressionNode, argList: ArgumentNode[], trailingComma: boolean): CallNode;
+}
+export interface ListComprehensionNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ListComprehension;
+    expression: ParseNode;
+    forIfNodes: ListComprehensionForIfNode[];
+    isParenthesized?: boolean;
+}
+export declare namespace ListComprehensionNode {
+    function create(expression: ParseNode): ListComprehensionNode;
+}
+export interface IndexNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Index;
+    baseExpression: ExpressionNode;
+    items: ArgumentNode[];
+    trailingComma: boolean;
+}
+export declare namespace IndexNode {
+    function create(baseExpression: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
+}
+export interface SliceNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Slice;
+    startValue?: ExpressionNode | undefined;
+    endValue?: ExpressionNode | undefined;
+    stepValue?: ExpressionNode | undefined;
+}
+export declare namespace SliceNode {
+    function create(range: TextRange): SliceNode;
+}
+export interface YieldNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Yield;
+    expression?: ExpressionNode | undefined;
+}
+export declare namespace YieldNode {
+    function create(yieldToken: Token, expression?: ExpressionNode): YieldNode;
+}
+export interface YieldFromNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.YieldFrom;
+    expression: ExpressionNode;
+}
+export declare namespace YieldFromNode {
+    function create(yieldToken: Token, expression: ExpressionNode): YieldFromNode;
+}
+export interface MemberAccessNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.MemberAccess;
+    leftExpression: ExpressionNode;
+    memberName: NameNode;
+}
+export declare namespace MemberAccessNode {
+    function create(leftExpression: ExpressionNode, memberName: NameNode): MemberAccessNode;
+}
+export interface LambdaNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Lambda;
+    parameters: ParameterNode[];
+    expression: ExpressionNode;
+}
+export declare namespace LambdaNode {
+    function create(lambdaToken: Token, expression: ExpressionNode): LambdaNode;
+}
+export interface NameNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Name;
+    token: IdentifierToken;
+    value: string;
+}
+export declare namespace NameNode {
+    function create(nameToken: IdentifierToken): NameNode;
+}
+export interface ConstantNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Constant;
+    constType: KeywordType;
+}
+export declare namespace ConstantNode {
+    function create(token: KeywordToken): ConstantNode;
+}
+export interface EllipsisNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Ellipsis;
+}
+export declare namespace EllipsisNode {
+    function create(range: TextRange): EllipsisNode;
+}
+export interface NumberNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Number;
+    value: number | bigint;
+    isInteger: boolean;
+    isImaginary: boolean;
+}
+export declare namespace NumberNode {
+    function create(token: NumberToken): NumberNode;
+}
+export interface StringNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.String;
+    token: StringToken;
+    value: string;
+    hasUnescapeErrors: boolean;
+}
+export declare namespace StringNode {
+    function create(token: StringToken, unescapedValue: string, hasUnescapeErrors: boolean): StringNode;
+}
+export interface FormatStringNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.FormatString;
+    token: StringToken;
+    value: string;
+    hasUnescapeErrors: boolean;
+    expressions: ExpressionNode[];
+}
+export declare namespace FormatStringNode {
+    function create(token: StringToken, unescapedValue: string, hasUnescapeErrors: boolean, expressions: ExpressionNode[]): FormatStringNode;
+}
+export interface StringListNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.StringList;
+    strings: (StringNode | FormatStringNode)[];
+    typeAnnotation?: ExpressionNode;
+    isParenthesized?: boolean;
+}
+export declare namespace StringListNode {
+    function create(strings: (StringNode | FormatStringNode)[]): StringListNode;
+}
+export interface DictionaryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Dictionary;
+    entries: DictionaryEntryNode[];
+    trailingCommaToken?: Token;
+}
+export declare namespace DictionaryNode {
+    function create(range: TextRange): DictionaryNode;
+}
+export interface DictionaryKeyEntryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.DictionaryKeyEntry;
+    keyExpression: ExpressionNode;
+    valueExpression: ExpressionNode;
+}
+export declare namespace DictionaryKeyEntryNode {
+    function create(keyExpression: ExpressionNode, valueExpression: ExpressionNode): DictionaryKeyEntryNode;
+}
+export interface DictionaryExpandEntryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.DictionaryExpandEntry;
+    expandExpression: ExpressionNode;
+}
+export declare namespace DictionaryExpandEntryNode {
+    function create(expandExpression: ExpressionNode): DictionaryExpandEntryNode;
+}
+export declare type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ListComprehensionNode;
+export interface SetNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Set;
+    entries: ExpressionNode[];
+}
+export declare namespace SetNode {
+    function create(range: TextRange): SetNode;
+}
+export interface ListNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.List;
+    entries: ExpressionNode[];
+}
+export declare namespace ListNode {
+    function create(range: TextRange): ListNode;
+}
+export declare const enum ArgumentCategory {
+    Simple = 0,
+    UnpackedList = 1,
+    UnpackedDictionary = 2
+}
+export interface ArgumentNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Argument;
+    argumentCategory: ArgumentCategory;
+    name?: NameNode | undefined;
+    valueExpression: ExpressionNode;
+}
+export declare namespace ArgumentNode {
+    function create(startToken: Token | undefined, valueExpression: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
+}
+export interface DelNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Del;
+    expressions: ExpressionNode[];
+}
+export declare namespace DelNode {
+    function create(delToken: Token): DelNode;
+}
+export interface PassNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Pass;
+}
+export declare namespace PassNode {
+    function create(passToken: TextRange): PassNode;
+}
+export interface ImportNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Import;
+    list: ImportAsNode[];
+}
+export declare namespace ImportNode {
+    function create(passToken: TextRange): ImportNode;
+}
+export interface ModuleNameNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ModuleName;
+    leadingDots: number;
+    nameParts: NameNode[];
+    hasTrailingDot?: boolean;
+}
+export declare namespace ModuleNameNode {
+    function create(range: TextRange): ModuleNameNode;
+}
+export interface ImportAsNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ImportAs;
+    module: ModuleNameNode;
+    alias?: NameNode | undefined;
+}
+export declare namespace ImportAsNode {
+    function create(module: ModuleNameNode): ImportAsNode;
+}
+export interface ImportFromNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ImportFrom;
+    module: ModuleNameNode;
+    imports: ImportFromAsNode[];
+    isWildcardImport: boolean;
+    usesParens: boolean;
+    wildcardToken?: Token;
+    missingImportKeyword?: boolean;
+}
+export declare namespace ImportFromNode {
+    function create(fromToken: Token, module: ModuleNameNode): ImportFromNode;
+}
+export interface ImportFromAsNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.ImportFromAs;
+    name: NameNode;
+    alias?: NameNode | undefined;
+}
+export declare namespace ImportFromAsNode {
+    function create(name: NameNode): ImportFromAsNode;
+}
+export interface GlobalNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Global;
+    nameList: NameNode[];
+}
+export declare namespace GlobalNode {
+    function create(range: TextRange): GlobalNode;
+}
+export interface NonlocalNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Nonlocal;
+    nameList: NameNode[];
+}
+export declare namespace NonlocalNode {
+    function create(range: TextRange): NonlocalNode;
+}
+export interface AssertNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Assert;
+    testExpression: ExpressionNode;
+    exceptionExpression?: ExpressionNode | undefined;
+}
+export declare namespace AssertNode {
+    function create(assertToken: Token, testExpression: ExpressionNode): AssertNode;
+}
+export interface BreakNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Break;
+}
+export declare namespace BreakNode {
+    function create(range: TextRange): BreakNode;
+}
+export interface ContinueNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Continue;
+}
+export declare namespace ContinueNode {
+    function create(range: TextRange): ContinueNode;
+}
+export interface ReturnNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Return;
+    returnExpression?: ExpressionNode | undefined;
+}
+export declare namespace ReturnNode {
+    function create(range: TextRange): ReturnNode;
+}
+export interface RaiseNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Raise;
+    typeExpression?: ExpressionNode | undefined;
+    valueExpression?: ExpressionNode | undefined;
+    tracebackExpression?: ExpressionNode | undefined;
+}
+export declare namespace RaiseNode {
+    function create(range: TextRange): RaiseNode;
+}
+export interface MatchNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Match;
+    subjectExpression: ExpressionNode;
+    cases: CaseNode[];
+}
+export declare namespace MatchNode {
+    function create(matchToken: TextRange, subjectExpression: ExpressionNode): MatchNode;
+}
+export interface CaseNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.Case;
+    pattern: PatternAtomNode;
+    isIrrefutable: boolean;
+    guardExpression?: ExpressionNode | undefined;
+    suite: SuiteNode;
+}
+export declare namespace CaseNode {
+    function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpression: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
+}
+export interface PatternSequenceNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternSequence;
+    entries: PatternAsNode[];
+    starEntryIndex: number | undefined;
+}
+export declare namespace PatternSequenceNode {
+    function create(firstToken: TextRange, entries: PatternAsNode[]): PatternSequenceNode;
+}
+export interface PatternAsNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternAs;
+    orPatterns: PatternAtomNode[];
+    target?: NameNode | undefined;
+}
+export declare namespace PatternAsNode {
+    function create(orPatterns: PatternAtomNode[], target?: NameNode): PatternAsNode;
+}
+export interface PatternLiteralNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternLiteral;
+    expression: ExpressionNode;
+}
+export declare namespace PatternLiteralNode {
+    function create(expression: ExpressionNode): PatternLiteralNode;
+}
+export interface PatternClassNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternClass;
+    className: NameNode | MemberAccessNode;
+    arguments: PatternClassArgumentNode[];
+}
+export declare namespace PatternClassNode {
+    function create(className: NameNode | MemberAccessNode, args: PatternClassArgumentNode[]): PatternClassNode;
+}
+export interface PatternClassArgumentNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternClassArgument;
+    name?: NameNode | undefined;
+    pattern: PatternAsNode;
+}
+export declare namespace PatternClassArgumentNode {
+    function create(pattern: PatternAsNode, name?: NameNode): PatternClassArgumentNode;
+}
+export interface PatternCaptureNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternCapture;
+    target: NameNode;
+    isStar: boolean;
+    isWildcard: boolean;
+}
+export declare namespace PatternCaptureNode {
+    function create(target: NameNode, starToken?: TextRange): PatternCaptureNode;
+}
+export interface PatternMappingNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternMapping;
+    entries: PatternMappingEntryNode[];
+}
+export declare namespace PatternMappingNode {
+    function create(startToken: TextRange, entries: PatternMappingEntryNode[]): PatternMappingNode;
+}
+export declare type PatternMappingEntryNode = PatternMappingKeyEntryNode | PatternMappingExpandEntryNode;
+export interface PatternMappingKeyEntryNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternMappingKeyEntry;
+    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 {
+    readonly nodeType: ParseNodeType.PatternMappingExpandEntry;
+    target: NameNode;
+}
+export declare namespace PatternMappingExpandEntryNode {
+    function create(starStarToken: TextRange, target: NameNode): PatternMappingExpandEntryNode;
+}
+export interface PatternValueNode extends ParseNodeBase {
+    readonly nodeType: ParseNodeType.PatternValue;
+    expression: MemberAccessNode;
+}
+export declare namespace PatternValueNode {
+    function create(expression: MemberAccessNode): PatternValueNode;
+}
+export declare type PatternAtomNode = PatternSequenceNode | PatternLiteralNode | PatternClassNode | PatternAsNode | PatternCaptureNode | PatternMappingNode | PatternValueNode | ErrorNode;
+export declare type ParseNode = ErrorNode | ArgumentNode | AssertNode | AssignmentExpressionNode | AssignmentNode | AugmentedAssignmentNode | AwaitNode | BinaryOperationNode | BreakNode | CallNode | CaseNode | ClassNode | ConstantNode | ContinueNode | DecoratorNode | DelNode | DictionaryNode | DictionaryExpandEntryNode | DictionaryKeyEntryNode | EllipsisNode | IfNode | ImportNode | ImportAsNode | ImportFromNode | ImportFromAsNode | IndexNode | ExceptNode | ForNode | FormatStringNode | FunctionNode | FunctionAnnotationNode | GlobalNode | LambdaNode | ListNode | ListComprehensionNode | ListComprehensionForNode | ListComprehensionIfNode | 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 | TypeAnnotationNode | UnaryOperationNode | UnpackNode | WhileNode | WithNode | WithItemNode | YieldNode | YieldFromNode;
+export declare type EvaluationScopeNode = LambdaNode | FunctionNode | ModuleNode | ClassNode | ListComprehensionNode;
+export declare type ExecutionScopeNode = LambdaNode | FunctionNode | ModuleNode;