@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240714

package/dist/parser/parseNodes.d.ts

@@ -97,176 +97,189 @@ export declare const enum ErrorExpressionCategory {
     MissingDictValue = 13,
     MaxDepthExceeded = 14
 }
-export interface MutableTextRange {
-    start: number;
-    length: number;
-}
-export interface ParseNodeBase extends MutableTextRange {
-    readonly nodeType: ParseNodeType;
+export interface ParseNodeBase<T extends ParseNodeType> {
+    readonly nodeType: T;
     readonly start: number;
     readonly length: number;
     id: number;
-    parent?: ParseNode | undefined;
-    maxChildDepth?: number;
+    parent: ParseNode | undefined;
+    a: object | undefined;
+    d: object;
 }
 export declare function getNextNodeId(): number;
-export declare function extendRange(node: ParseNodeBase, newRange: TextRange): void;
+export declare function extendRange(node: ParseNodeBase<any>, newRange: TextRange): void;
 export type ParseNodeArray = (ParseNode | undefined)[];
-export interface ModuleNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Module;
-    statements: StatementNode[];
+export interface ModuleNode extends ParseNodeBase<ParseNodeType.Module> {
+    d: {
+        statements: StatementNode[];
+    };
 }
 export declare namespace ModuleNode {
     function create(range: TextRange): ModuleNode;
 }
-export interface SuiteNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Suite;
-    statements: StatementNode[];
-    typeComment?: StringToken;
+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 {
-    readonly nodeType: ParseNodeType.If;
-    testExpression: ExpressionNode;
-    ifSuite: SuiteNode;
-    elseSuite?: SuiteNode | IfNode | undefined;
+export interface IfNode extends ParseNodeBase<ParseNodeType.If> {
+    d: {
+        testExpr: ExpressionNode;
+        ifSuite: SuiteNode;
+        elseSuite: SuiteNode | IfNode | undefined;
+    };
 }
 export declare namespace IfNode {
-    function create(ifOrElifToken: Token, testExpression: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
+    function create(ifOrElifToken: Token, testExpr: ExpressionNode, ifSuite: SuiteNode, elseSuite?: SuiteNode): IfNode;
 }
-export interface WhileNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.While;
-    testExpression: ExpressionNode;
-    whileSuite: SuiteNode;
-    elseSuite?: SuiteNode | undefined;
+export interface WhileNode extends ParseNodeBase<ParseNodeType.While> {
+    d: {
+        testExpr: 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;
-    typeComment?: StringToken;
+    function create(whileToken: Token, testExpr: ExpressionNode, whileSuite: SuiteNode): WhileNode;
+}
+export interface ForNode extends ParseNodeBase<ParseNodeType.For> {
+    d: {
+        isAsync?: boolean;
+        asyncToken?: Token;
+        targetExpr: ExpressionNode;
+        iterableExpr: ExpressionNode;
+        forSuite: SuiteNode;
+        elseSuite?: SuiteNode | undefined;
+        typeComment?: StringToken;
+    };
 }
 export declare namespace ForNode {
-    function create(forToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode, forSuite: SuiteNode): ForNode;
+    function create(forToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode, forSuite: SuiteNode): ForNode;
 }
 export type ComprehensionForIfNode = ComprehensionForNode | ComprehensionIfNode;
-export interface ComprehensionForNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.ComprehensionFor;
-    isAsync?: boolean;
-    asyncToken?: Token;
-    targetExpression: ExpressionNode;
-    iterableExpression: ExpressionNode;
+export interface ComprehensionForNode extends ParseNodeBase<ParseNodeType.ComprehensionFor> {
+    d: {
+        isAsync?: boolean;
+        asyncToken?: Token;
+        targetExpr: ExpressionNode;
+        iterableExpr: ExpressionNode;
+    };
 }
 export declare namespace ComprehensionForNode {
-    function create(startToken: Token, targetExpression: ExpressionNode, iterableExpression: ExpressionNode): ComprehensionForNode;
+    function create(startToken: Token, targetExpr: ExpressionNode, iterableExpr: ExpressionNode): ComprehensionForNode;
 }
-export interface ComprehensionIfNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.ComprehensionIf;
-    testExpression: ExpressionNode;
+export interface ComprehensionIfNode extends ParseNodeBase<ParseNodeType.ComprehensionIf> {
+    d: {
+        testExpr: ExpressionNode;
+    };
 }
 export declare namespace ComprehensionIfNode {
-    function create(ifToken: Token, testExpression: ExpressionNode): ComprehensionIfNode;
+    function create(ifToken: Token, testExpr: ExpressionNode): ComprehensionIfNode;
 }
-export interface TryNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Try;
-    trySuite: SuiteNode;
-    exceptClauses: ExceptNode[];
-    elseSuite?: SuiteNode | undefined;
-    finallySuite?: SuiteNode | undefined;
+export interface TryNode extends ParseNodeBase<ParseNodeType.Try> {
+    d: {
+        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 interface ExceptNode extends ParseNodeBase<ParseNodeType.Except> {
+    d: {
+        typeExpr?: 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;
-    typeParameters?: TypeParameterListNode;
-    parameters: ParameterNode[];
-    returnTypeAnnotation?: ExpressionNode | undefined;
-    functionAnnotationComment?: FunctionAnnotationNode | undefined;
-    suite: SuiteNode;
+export interface FunctionNode extends ParseNodeBase<ParseNodeType.Function> {
+    d: {
+        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, typeParameters?: TypeParameterListNode): FunctionNode;
+    function create(defToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): FunctionNode;
 }
 export declare const enum ParameterCategory {
     Simple = 0,
     ArgsList = 1,
     KwargsDict = 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 interface ParameterNode extends ParseNodeBase<ParseNodeType.Parameter> {
+    d: {
+        category: ParameterCategory;
+        name: NameNode | undefined;
+        annotation: ExpressionNode | undefined;
+        annotationComment: 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;
-    typeParameters?: TypeParameterListNode;
-    arguments: ArgumentNode[];
-    suite: SuiteNode;
+export interface ClassNode extends ParseNodeBase<ParseNodeType.Class> {
+    d: {
+        decorators: DecoratorNode[];
+        name: NameNode;
+        typeParams: TypeParameterListNode | undefined;
+        arguments: ArgumentNode[];
+        suite: SuiteNode;
+    };
 }
 export declare namespace ClassNode {
-    function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParameters?: TypeParameterListNode): ClassNode;
+    function create(classToken: Token, name: NameNode, suite: SuiteNode, typeParams?: TypeParameterListNode): ClassNode;
     function createDummyForDecorators(decorators: DecoratorNode[]): ClassNode;
 }
-export interface WithNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.With;
-    isAsync?: boolean;
-    asyncToken?: Token;
-    withItems: WithItemNode[];
-    suite: SuiteNode;
-    typeComment?: StringToken;
+export interface WithNode extends ParseNodeBase<ParseNodeType.With> {
+    d: {
+        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 {
-    readonly nodeType: ParseNodeType.WithItem;
-    expression: ExpressionNode;
-    target?: ExpressionNode | undefined;
+export interface WithItemNode extends ParseNodeBase<ParseNodeType.WithItem> {
+    d: {
+        expr: ExpressionNode;
+        target?: ExpressionNode | undefined;
+    };
 }
 export declare namespace WithItemNode {
-    function create(expression: ExpressionNode): WithItemNode;
+    function create(expr: ExpressionNode): WithItemNode;
 }
-export interface DecoratorNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Decorator;
-    expression: ExpressionNode;
+export interface DecoratorNode extends ParseNodeBase<ParseNodeType.Decorator> {
+    d: {
+        expr: ExpressionNode;
+    };
 }
 export declare namespace DecoratorNode {
-    function create(atToken: Token, expression: ExpressionNode): DecoratorNode;
+    function create(atToken: Token, expr: ExpressionNode): DecoratorNode;
 }
-export interface StatementListNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.StatementList;
-    statements: ParseNode[];
+export interface StatementListNode extends ParseNodeBase<ParseNodeType.StatementList> {
+    d: {
+        statements: ParseNode[];
+    };
 }
 export declare namespace StatementListNode {
     function create(atToken: Token): StatementListNode;
@@ -275,306 +288,339 @@ export type StatementNode = IfNode | WhileNode | ForNode | TryNode | FunctionNod
 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 {
-    readonly nodeType: ParseNodeType.Error;
-    readonly category: ErrorExpressionCategory;
-    readonly child?: ExpressionNode | undefined;
-    readonly decorators?: DecoratorNode[] | undefined;
+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 {
-    readonly nodeType: ParseNodeType.UnaryOperation;
-    expression: ExpressionNode;
-    operatorToken: Token;
-    operator: OperatorType;
-    parenthesized?: boolean;
+export interface UnaryOperationNode extends ParseNodeBase<ParseNodeType.UnaryOperation> {
+    d: {
+        expr: ExpressionNode;
+        operatorToken: Token;
+        operator: OperatorType;
+        hasParens: boolean;
+    };
 }
 export declare namespace UnaryOperationNode {
-    function create(operatorToken: Token, expression: ExpressionNode, operator: OperatorType): UnaryOperationNode;
+    function create(operatorToken: Token, expr: ExpressionNode, operator: OperatorType): UnaryOperationNode;
 }
-export interface BinaryOperationNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.BinaryOperation;
-    leftExpression: ExpressionNode;
-    operatorToken: Token;
-    operator: OperatorType;
-    rightExpression: ExpressionNode;
-    parenthesized?: boolean;
+export interface BinaryOperationNode extends ParseNodeBase<ParseNodeType.BinaryOperation> {
+    d: {
+        leftExpr: ExpressionNode;
+        operatorToken: Token;
+        operator: OperatorType;
+        rightExpr: ExpressionNode;
+        hasParens: boolean;
+    };
 }
 export declare namespace BinaryOperationNode {
-    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
+    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operatorToken: Token, operator: OperatorType): BinaryOperationNode;
 }
-export interface AssignmentExpressionNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.AssignmentExpression;
-    name: NameNode;
-    walrusToken: Token;
-    rightExpression: ExpressionNode;
-    isParenthesized: boolean;
+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, rightExpression: ExpressionNode): AssignmentExpressionNode;
+    function create(name: NameNode, walrusToken: Token, rightExpr: ExpressionNode): AssignmentExpressionNode;
 }
-export interface AssignmentNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Assignment;
-    leftExpression: ExpressionNode;
-    rightExpression: ExpressionNode;
-    typeAnnotationComment?: ExpressionNode | undefined;
-    chainedTypeAnnotationComment?: ExpressionNode | undefined;
+export interface AssignmentNode extends ParseNodeBase<ParseNodeType.Assignment> {
+    d: {
+        leftExpr: ExpressionNode;
+        rightExpr: ExpressionNode;
+        annotationComment?: ExpressionNode | undefined;
+        chainedAnnotationComment?: ExpressionNode | undefined;
+    };
 }
 export declare namespace AssignmentNode {
-    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode): AssignmentNode;
+    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode): AssignmentNode;
 }
-export declare enum TypeParameterCategory {
+export declare enum TypeParameterKind {
     TypeVar = 0,
     TypeVarTuple = 1,
     ParamSpec = 2
 }
-export interface TypeParameterNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.TypeParameter;
-    name: NameNode;
-    typeParamCategory: TypeParameterCategory;
-    boundExpression?: ExpressionNode;
-    defaultExpression?: ExpressionNode;
+export interface TypeParameterNode extends ParseNodeBase<ParseNodeType.TypeParameter> {
+    d: {
+        name: NameNode;
+        typeParamKind: TypeParameterKind;
+        boundExpr?: ExpressionNode;
+        defaultExpr?: ExpressionNode;
+    };
 }
 export declare namespace TypeParameterNode {
-    function create(name: NameNode, typeParamCategory: TypeParameterCategory, boundExpression?: ExpressionNode, defaultExpression?: ExpressionNode): TypeParameterNode;
+    function create(name: NameNode, typeParamKind: TypeParameterKind, boundExpr?: ExpressionNode, defaultExpr?: ExpressionNode): TypeParameterNode;
 }
-export interface TypeParameterListNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.TypeParameterList;
-    parameters: TypeParameterNode[];
+export interface TypeParameterListNode extends ParseNodeBase<ParseNodeType.TypeParameterList> {
+    d: {
+        params: TypeParameterNode[];
+    };
 }
 export declare namespace TypeParameterListNode {
-    function create(startToken: Token, endToken: Token, parameters: TypeParameterNode[]): TypeParameterListNode;
+    function create(startToken: Token, endToken: Token, params: TypeParameterNode[]): TypeParameterListNode;
 }
-export interface TypeAliasNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.TypeAlias;
-    name: NameNode;
-    typeParameters?: TypeParameterListNode;
-    expression: ExpressionNode;
+export interface TypeAliasNode extends ParseNodeBase<ParseNodeType.TypeAlias> {
+    d: {
+        name: NameNode;
+        typeParams?: TypeParameterListNode;
+        expr: ExpressionNode;
+    };
 }
 export declare namespace TypeAliasNode {
-    function create(typeToken: KeywordToken, name: NameNode, expression: ExpressionNode, typeParameters?: TypeParameterListNode): TypeAliasNode;
+    function create(typeToken: KeywordToken, name: NameNode, expr: ExpressionNode, typeParams?: TypeParameterListNode): TypeAliasNode;
 }
-export interface TypeAnnotationNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.TypeAnnotation;
-    valueExpression: ExpressionNode;
-    typeAnnotation: ExpressionNode;
+export interface TypeAnnotationNode extends ParseNodeBase<ParseNodeType.TypeAnnotation> {
+    d: {
+        valueExpr: ExpressionNode;
+        annotation: ExpressionNode;
+    };
 }
 export declare namespace TypeAnnotationNode {
-    function create(valueExpression: ExpressionNode, typeAnnotation: ExpressionNode): TypeAnnotationNode;
+    function create(valueExpr: ExpressionNode, annotation: ExpressionNode): TypeAnnotationNode;
 }
-export interface FunctionAnnotationNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.FunctionAnnotation;
-    isParamListEllipsis: boolean;
-    paramTypeAnnotations: ExpressionNode[];
-    returnTypeAnnotation: ExpressionNode;
+export interface FunctionAnnotationNode extends ParseNodeBase<ParseNodeType.FunctionAnnotation> {
+    d: {
+        isEllipsis: boolean;
+        paramAnnotations: ExpressionNode[];
+        returnAnnotation: ExpressionNode;
+    };
 }
 export declare namespace FunctionAnnotationNode {
-    function create(openParenToken: Token, isParamListEllipsis: boolean, paramTypeAnnotations: ExpressionNode[], returnTypeAnnotation: ExpressionNode): FunctionAnnotationNode;
+    function create(openParenToken: Token, isEllipsis: boolean, paramAnnotations: ExpressionNode[], returnAnnotation: ExpressionNode): FunctionAnnotationNode;
 }
-export interface AugmentedAssignmentNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.AugmentedAssignment;
-    leftExpression: ExpressionNode;
-    operator: OperatorType;
-    rightExpression: ExpressionNode;
-    destExpression: ExpressionNode;
+export interface AugmentedAssignmentNode extends ParseNodeBase<ParseNodeType.AugmentedAssignment> {
+    d: {
+        leftExpr: ExpressionNode;
+        operator: OperatorType;
+        rightExpr: ExpressionNode;
+        destExpr: ExpressionNode;
+    };
 }
 export declare namespace AugmentedAssignmentNode {
-    function create(leftExpression: ExpressionNode, rightExpression: ExpressionNode, operator: OperatorType, destExpression: ExpressionNode): AugmentedAssignmentNode;
+    function create(leftExpr: ExpressionNode, rightExpr: ExpressionNode, operator: OperatorType, destExpr: ExpressionNode): AugmentedAssignmentNode;
 }
-export interface AwaitNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Await;
-    expression: ExpressionNode;
-    parenthesized?: boolean;
+export interface AwaitNode extends ParseNodeBase<ParseNodeType.Await> {
+    d: {
+        expr: ExpressionNode;
+        hasParens?: boolean;
+    };
 }
 export declare namespace AwaitNode {
-    function create(awaitToken: Token, expression: ExpressionNode): AwaitNode;
+    function create(awaitToken: Token, expr: ExpressionNode): AwaitNode;
 }
-export interface TernaryNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Ternary;
-    ifExpression: ExpressionNode;
-    testExpression: ExpressionNode;
-    elseExpression: ExpressionNode;
+export interface TernaryNode extends ParseNodeBase<ParseNodeType.Ternary> {
+    d: {
+        ifExpr: ExpressionNode;
+        testExpr: ExpressionNode;
+        elseExpr: ExpressionNode;
+    };
 }
 export declare namespace TernaryNode {
-    function create(ifExpression: ExpressionNode, testExpression: ExpressionNode, elseExpression: ExpressionNode): TernaryNode;
+    function create(ifExpr: ExpressionNode, testExpr: ExpressionNode, elseExpr: ExpressionNode): TernaryNode;
 }
-export interface UnpackNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Unpack;
-    expression: ExpressionNode;
-    starToken: Token;
+export interface UnpackNode extends ParseNodeBase<ParseNodeType.Unpack> {
+    d: {
+        expr: ExpressionNode;
+        starToken: Token;
+    };
 }
 export declare namespace UnpackNode {
-    function create(starToken: Token, expression: ExpressionNode): UnpackNode;
+    function create(starToken: Token, expr: ExpressionNode): UnpackNode;
 }
-export interface TupleNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Tuple;
-    expressions: ExpressionNode[];
-    enclosedInParens: boolean;
+export interface TupleNode extends ParseNodeBase<ParseNodeType.Tuple> {
+    d: {
+        items: ExpressionNode[];
+        hasParens: boolean;
+    };
 }
 export declare namespace TupleNode {
-    function create(range: TextRange, enclosedInParens: boolean): TupleNode;
+    function create(range: TextRange, hasParens: boolean): TupleNode;
 }
-export interface CallNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Call;
-    leftExpression: ExpressionNode;
-    arguments: ArgumentNode[];
-    trailingComma: boolean;
+export interface CallNode extends ParseNodeBase<ParseNodeType.Call> {
+    d: {
+        leftExpr: ExpressionNode;
+        args: ArgumentNode[];
+        trailingComma: boolean;
+    };
 }
 export declare namespace CallNode {
-    function create(leftExpression: ExpressionNode, argList: ArgumentNode[], trailingComma: boolean): CallNode;
+    function create(leftExpr: ExpressionNode, args: ArgumentNode[], trailingComma: boolean): CallNode;
 }
-export interface ComprehensionNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Comprehension;
-    expression: ParseNode;
-    forIfNodes: ComprehensionForIfNode[];
-    isGenerator: boolean;
-    isParenthesized?: boolean;
+export interface ComprehensionNode extends ParseNodeBase<ParseNodeType.Comprehension> {
+    d: {
+        expr: ParseNode;
+        forIfNodes: ComprehensionForIfNode[];
+        isGenerator: boolean;
+        hasParens?: boolean;
+    };
 }
 export declare namespace ComprehensionNode {
-    function create(expression: ParseNode, isGenerator: boolean): ComprehensionNode;
+    function create(expr: ParseNode, isGenerator: boolean): ComprehensionNode;
 }
-export interface IndexNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Index;
-    baseExpression: ExpressionNode;
-    items: ArgumentNode[];
-    trailingComma: boolean;
+export interface IndexNode extends ParseNodeBase<ParseNodeType.Index> {
+    d: {
+        leftExpr: ExpressionNode;
+        items: ArgumentNode[];
+        trailingComma: boolean;
+    };
 }
 export declare namespace IndexNode {
-    function create(baseExpression: ExpressionNode, items: ArgumentNode[], trailingComma: boolean, closeBracketToken: Token): IndexNode;
+    function create(leftExpr: 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 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 {
-    readonly nodeType: ParseNodeType.Yield;
-    expression?: ExpressionNode | undefined;
+export interface YieldNode extends ParseNodeBase<ParseNodeType.Yield> {
+    d: {
+        expr?: ExpressionNode | undefined;
+    };
 }
 export declare namespace YieldNode {
-    function create(yieldToken: Token, expression?: ExpressionNode): YieldNode;
+    function create(yieldToken: Token, expr?: ExpressionNode): YieldNode;
 }
-export interface YieldFromNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.YieldFrom;
-    expression: ExpressionNode;
+export interface YieldFromNode extends ParseNodeBase<ParseNodeType.YieldFrom> {
+    d: {
+        expr: ExpressionNode;
+    };
 }
 export declare namespace YieldFromNode {
-    function create(yieldToken: Token, expression: ExpressionNode): YieldFromNode;
+    function create(yieldToken: Token, expr: ExpressionNode): YieldFromNode;
 }
-export interface MemberAccessNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.MemberAccess;
-    leftExpression: ExpressionNode;
-    memberName: NameNode;
+export interface MemberAccessNode extends ParseNodeBase<ParseNodeType.MemberAccess> {
+    d: {
+        leftExpr: ExpressionNode;
+        member: NameNode;
+    };
 }
 export declare namespace MemberAccessNode {
-    function create(leftExpression: ExpressionNode, memberName: NameNode): MemberAccessNode;
+    function create(leftExpr: ExpressionNode, member: NameNode): MemberAccessNode;
 }
-export interface LambdaNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Lambda;
-    parameters: ParameterNode[];
-    expression: ExpressionNode;
+export interface LambdaNode extends ParseNodeBase<ParseNodeType.Lambda> {
+    d: {
+        params: ParameterNode[];
+        expr: ExpressionNode;
+    };
 }
 export declare namespace LambdaNode {
-    function create(lambdaToken: Token, expression: ExpressionNode): LambdaNode;
+    function create(lambdaToken: Token, expr: ExpressionNode): LambdaNode;
 }
-export interface NameNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Name;
-    token: IdentifierToken;
-    value: string;
+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 {
-    readonly nodeType: ParseNodeType.Constant;
-    constType: KeywordType;
+export interface ConstantNode extends ParseNodeBase<ParseNodeType.Constant> {
+    d: {
+        constType: KeywordType;
+    };
 }
 export declare namespace ConstantNode {
     function create(token: KeywordToken): ConstantNode;
 }
-export interface EllipsisNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Ellipsis;
+export interface EllipsisNode extends ParseNodeBase<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 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 {
-    readonly nodeType: ParseNodeType.String;
-    token: StringToken;
-    value: string;
+export interface StringNode extends ParseNodeBase<ParseNodeType.String> {
+    d: {
+        token: StringToken;
+        value: string;
+    };
 }
 export declare namespace StringNode {
-    function create(token: StringToken, unescapedValue: string): StringNode;
+    function create(token: StringToken, value: string): StringNode;
 }
-export interface FormatStringNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.FormatString;
-    token: FStringStartToken;
-    middleTokens: FStringMiddleToken[];
-    fieldExpressions: ExpressionNode[];
-    formatExpressions: ExpressionNode[];
-    value: '';
+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[], fieldExpressions: ExpressionNode[], formatExpressions: ExpressionNode[]): FormatStringNode;
+    function create(startToken: FStringStartToken, endToken: FStringEndToken | undefined, middleTokens: FStringMiddleToken[], fieldExprs: ExpressionNode[], formatExprs: ExpressionNode[]): FormatStringNode;
 }
-export interface StringListNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.StringList;
-    strings: (StringNode | FormatStringNode)[];
-    typeAnnotation?: ExpressionNode;
-    isParenthesized?: boolean;
+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 {
-    readonly nodeType: ParseNodeType.Dictionary;
-    entries: DictionaryEntryNode[];
-    trailingCommaToken?: Token;
+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 {
-    readonly nodeType: ParseNodeType.DictionaryKeyEntry;
-    keyExpression: ExpressionNode;
-    valueExpression: ExpressionNode;
+export interface DictionaryKeyEntryNode extends ParseNodeBase<ParseNodeType.DictionaryKeyEntry> {
+    d: {
+        keyExpr: ExpressionNode;
+        valueExpr: ExpressionNode;
+    };
 }
 export declare namespace DictionaryKeyEntryNode {
-    function create(keyExpression: ExpressionNode, valueExpression: ExpressionNode): DictionaryKeyEntryNode;
+    function create(keyExpr: ExpressionNode, valueExpr: ExpressionNode): DictionaryKeyEntryNode;
 }
-export interface DictionaryExpandEntryNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.DictionaryExpandEntry;
-    expandExpression: ExpressionNode;
+export interface DictionaryExpandEntryNode extends ParseNodeBase<ParseNodeType.DictionaryExpandEntry> {
+    d: {
+        expr: ExpressionNode;
+    };
 }
 export declare namespace DictionaryExpandEntryNode {
-    function create(expandExpression: ExpressionNode): DictionaryExpandEntryNode;
+    function create(expr: ExpressionNode): DictionaryExpandEntryNode;
 }
 export type DictionaryEntryNode = DictionaryKeyEntryNode | DictionaryExpandEntryNode | ComprehensionNode;
-export interface SetNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Set;
-    entries: ExpressionNode[];
+export interface SetNode extends ParseNodeBase<ParseNodeType.Set> {
+    d: {
+        items: ExpressionNode[];
+    };
 }
 export declare namespace SetNode {
     function create(range: TextRange): SetNode;
 }
-export interface ListNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.List;
-    entries: ExpressionNode[];
+export interface ListNode extends ParseNodeBase<ParseNodeType.List> {
+    d: {
+        items: ExpressionNode[];
+    };
 }
 export declare namespace ListNode {
     function create(range: TextRange): ListNode;
@@ -584,217 +630,238 @@ export declare const enum ArgumentCategory {
     UnpackedList = 1,
     UnpackedDictionary = 2
 }
-export interface ArgumentNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Argument;
-    argumentCategory: ArgumentCategory;
-    name?: NameNode | undefined;
-    valueExpression: ExpressionNode;
+export interface ArgumentNode extends ParseNodeBase<ParseNodeType.Argument> {
+    d: {
+        argCategory: ArgumentCategory;
+        name: NameNode | undefined;
+        valueExpr: ExpressionNode;
+    };
 }
 export declare namespace ArgumentNode {
-    function create(startToken: Token | undefined, valueExpression: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
+    function create(startToken: Token | undefined, valueExpr: ExpressionNode, argCategory: ArgumentCategory): ArgumentNode;
 }
-export interface DelNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Del;
-    expressions: ExpressionNode[];
+export interface DelNode extends ParseNodeBase<ParseNodeType.Del> {
+    d: {
+        targets: ExpressionNode[];
+    };
 }
 export declare namespace DelNode {
     function create(delToken: Token): DelNode;
 }
-export interface PassNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Pass;
+export interface PassNode extends ParseNodeBase<ParseNodeType.Pass> {
 }
 export declare namespace PassNode {
     function create(passToken: TextRange): PassNode;
 }
-export interface ImportNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Import;
-    list: ImportAsNode[];
+export interface ImportNode extends ParseNodeBase<ParseNodeType.Import> {
+    d: {
+        list: ImportAsNode[];
+    };
 }
 export declare namespace ImportNode {
-    function create(passToken: TextRange): ImportNode;
+    function create(importToken: TextRange): ImportNode;
 }
-export interface ModuleNameNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.ModuleName;
-    leadingDots: number;
-    nameParts: NameNode[];
-    hasTrailingDot?: boolean;
+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 {
-    readonly nodeType: ParseNodeType.ImportAs;
-    module: ModuleNameNode;
-    alias?: NameNode | undefined;
+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 {
-    readonly nodeType: ParseNodeType.ImportFrom;
-    module: ModuleNameNode;
-    imports: ImportFromAsNode[];
-    isWildcardImport: boolean;
-    usesParens: boolean;
-    wildcardToken?: Token;
-    missingImportKeyword?: boolean;
+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 {
-    readonly nodeType: ParseNodeType.ImportFromAs;
-    name: NameNode;
-    alias?: NameNode | undefined;
+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 {
-    readonly nodeType: ParseNodeType.Global;
-    nameList: NameNode[];
+export interface GlobalNode extends ParseNodeBase<ParseNodeType.Global> {
+    d: {
+        targets: NameNode[];
+    };
 }
 export declare namespace GlobalNode {
     function create(range: TextRange): GlobalNode;
 }
-export interface NonlocalNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Nonlocal;
-    nameList: NameNode[];
+export interface NonlocalNode extends ParseNodeBase<ParseNodeType.Nonlocal> {
+    d: {
+        targets: 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 interface AssertNode extends ParseNodeBase<ParseNodeType.Assert> {
+    d: {
+        testExpr: ExpressionNode;
+        exceptionExpr?: ExpressionNode | undefined;
+    };
 }
 export declare namespace AssertNode {
-    function create(assertToken: Token, testExpression: ExpressionNode): AssertNode;
+    function create(assertToken: Token, testExpr: ExpressionNode): AssertNode;
 }
-export interface BreakNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Break;
+export interface BreakNode extends ParseNodeBase<ParseNodeType.Break> {
 }
 export declare namespace BreakNode {
     function create(range: TextRange): BreakNode;
 }
-export interface ContinueNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Continue;
+export interface ContinueNode extends ParseNodeBase<ParseNodeType.Continue> {
 }
 export declare namespace ContinueNode {
     function create(range: TextRange): ContinueNode;
 }
-export interface ReturnNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Return;
-    returnExpression?: ExpressionNode | undefined;
+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 {
-    readonly nodeType: ParseNodeType.Raise;
-    typeExpression?: ExpressionNode | undefined;
-    valueExpression?: ExpressionNode | undefined;
-    tracebackExpression?: ExpressionNode | undefined;
+export interface RaiseNode extends ParseNodeBase<ParseNodeType.Raise> {
+    d: {
+        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 interface MatchNode extends ParseNodeBase<ParseNodeType.Match> {
+    d: {
+        expr: ExpressionNode;
+        cases: CaseNode[];
+    };
 }
 export declare namespace MatchNode {
-    function create(matchToken: TextRange, subjectExpression: ExpressionNode): MatchNode;
+    function create(matchToken: TextRange, expr: ExpressionNode): MatchNode;
 }
-export interface CaseNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.Case;
-    pattern: PatternAtomNode;
-    isIrrefutable: boolean;
-    guardExpression?: ExpressionNode | undefined;
-    suite: SuiteNode;
+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, guardExpression: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
+    function create(caseToken: TextRange, pattern: PatternAtomNode, isIrrefutable: boolean, guardExpr: ExpressionNode | undefined, suite: SuiteNode): CaseNode;
 }
-export interface PatternSequenceNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.PatternSequence;
-    entries: PatternAsNode[];
-    starEntryIndex: number | undefined;
+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 {
-    readonly nodeType: ParseNodeType.PatternAs;
-    orPatterns: PatternAtomNode[];
-    target?: NameNode | undefined;
+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 {
-    readonly nodeType: ParseNodeType.PatternLiteral;
-    expression: ExpressionNode;
+export interface PatternLiteralNode extends ParseNodeBase<ParseNodeType.PatternLiteral> {
+    d: {
+        expr: ExpressionNode;
+    };
 }
 export declare namespace PatternLiteralNode {
-    function create(expression: ExpressionNode): PatternLiteralNode;
+    function create(expr: ExpressionNode): PatternLiteralNode;
 }
-export interface PatternClassNode extends ParseNodeBase {
-    readonly nodeType: ParseNodeType.PatternClass;
-    className: NameNode | MemberAccessNode;
-    arguments: PatternClassArgumentNode[];
+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 {
-    readonly nodeType: ParseNodeType.PatternClassArgument;
-    name?: NameNode | undefined;
-    pattern: PatternAsNode;
+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 {
-    readonly nodeType: ParseNodeType.PatternCapture;
-    target: NameNode;
-    isStar: boolean;
-    isWildcard: boolean;
+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 {
-    readonly nodeType: ParseNodeType.PatternMapping;
-    entries: PatternMappingEntryNode[];
+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 {
-    readonly nodeType: ParseNodeType.PatternMappingKeyEntry;
-    keyPattern: PatternLiteralNode | PatternValueNode | ErrorNode;
-    valuePattern: PatternAsNode | ErrorNode;
+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 {
-    readonly nodeType: ParseNodeType.PatternMappingExpandEntry;
-    target: NameNode;
+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 {
-    readonly nodeType: ParseNodeType.PatternValue;
-    expression: MemberAccessNode;
+export interface PatternValueNode extends ParseNodeBase<ParseNodeType.PatternValue> {
+    d: {
+        expr: MemberAccessNode;
+    };
 }
 export declare namespace PatternValueNode {
-    function create(expression: MemberAccessNode): 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;