@types/estree

elements: Array<Expression | SpreadElement | null>;

type: 'ArrayExpression';

elements: Array<Pattern | null>;

type: 'ArrayPattern';

body: BlockStatement | Expression;

expression: boolean;

type: 'ArrowFunctionExpression';

left: Pattern | MemberExpression;

operator: AssignmentOperator;

right: Expression;

type: 'AssignmentExpression';

left: Pattern;

right: Expression;

type: 'AssignmentPattern';

kind: 'init';

method: boolean;

value: Pattern;

argument: Expression;

type: 'AwaitExpression';

arguments: Array<Expression | SpreadElement>;

callee: Expression | Super;

body: ClassBody;

superClass?: Expression | null | undefined;

body: Statement;

left: VariableDeclaration | Pattern;

right: Expression;

async?: boolean | undefined;

body: BlockStatement | Expression;

generator?: boolean | undefined;

params: Pattern[];

local: Identifier;

leadingComments?: Comment[] | undefined;

trailingComments?: Comment[] | undefined;

loc?: SourceLocation | null | undefined;

range?: [number, number] | undefined;

type: string;

bigint: string;

raw?: string | undefined;

type: 'Literal';

value?: bigint | null | undefined;

left: Expression;

operator: BinaryOperator;

right: Expression;

type: 'BinaryExpression';

body: Statement[];

innerComments?: Comment[] | undefined;

type: 'BlockStatement';

label?: Identifier | null | undefined;

type: 'BreakStatement';

body: BlockStatement;

param: Pattern | null;

type: 'CatchClause';

expression: ChainElement;

type: 'ChainExpression';

body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;

type: 'ClassBody';

id: Identifier | null;

type: 'ClassDeclaration';

id?: Identifier | null | undefined;

type: 'ClassExpression';

type: 'Line' | 'Block';

value: string;

alternate: Expression;

consequent: Expression;

test: Expression;

type: 'ConditionalExpression';

label?: Identifier | null | undefined;

type: 'ContinueStatement';

type: 'DebuggerStatement';

directive: string;

expression: Literal;

type: 'ExpressionStatement';

body: Statement;

test: Expression;

type: 'DoWhileStatement';

type: 'EmptyStatement';

exported: Identifier | null;

source: Literal;

type: 'ExportAllDeclaration';

declaration: Declaration | Expression;

type: 'ExportDefaultDeclaration';

declaration?: Declaration | null | undefined;

source?: Literal | null | undefined;

specifiers: ExportSpecifier[];

type: 'ExportNamedDeclaration';

exported: Identifier;

type: 'ExportSpecifier';

ArrayExpression: ArrayExpression;

ArrowFunctionExpression: ArrowFunctionExpression;

AssignmentExpression: AssignmentExpression;

AwaitExpression: AwaitExpression;

BinaryExpression: BinaryExpression;

CallExpression: CallExpression;

ChainExpression: ChainExpression;

ClassExpression: ClassExpression;

ConditionalExpression: ConditionalExpression;

FunctionExpression: FunctionExpression;

Identifier: Identifier;

ImportExpression: ImportExpression;

Literal: Literal;

LogicalExpression: LogicalExpression;

MemberExpression: MemberExpression;

MetaProperty: MetaProperty;

NewExpression: NewExpression;

ObjectExpression: ObjectExpression;

SequenceExpression: SequenceExpression;

TaggedTemplateExpression: TaggedTemplateExpression;

TemplateLiteral: TemplateLiteral;

ThisExpression: ThisExpression;

UnaryExpression: UnaryExpression;

UpdateExpression: UpdateExpression;

YieldExpression: YieldExpression;

expression: Expression;

type: 'ExpressionStatement';

type: 'ForInStatement';

await: boolean;

type: 'ForOfStatement';

body: Statement;

init?: VariableDeclaration | Expression | null | undefined;

test?: Expression | null | undefined;

type: 'ForStatement';

update?: Expression | null | undefined;

body: BlockStatement;

id: Identifier | null;

type: 'FunctionDeclaration';

body: BlockStatement;

id?: Identifier | null | undefined;

type: 'FunctionExpression';

name: string;

type: 'Identifier';

alternate?: Statement | null | undefined;

consequent: Statement;

test: Expression;

type: 'IfStatement';

source: Literal;

specifiers: Array<
    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
>;

type: 'ImportDeclaration';

type: 'ImportDefaultSpecifier';

source: Expression;

type: 'ImportExpression';

type: 'ImportNamespaceSpecifier';

imported: Identifier;

type: 'ImportSpecifier';

body: Statement;

label: Identifier;

type: 'LabeledStatement';

left: Expression;

operator: LogicalOperator;

right: Expression;

type: 'LogicalExpression';

computed: boolean;

object: Expression | Super;

optional: boolean;

property: Expression | PrivateIdentifier;

type: 'MemberExpression';

meta: Identifier;

property: Identifier;

type: 'MetaProperty';

computed: boolean;

key: Expression | PrivateIdentifier;

kind: 'constructor' | 'method' | 'get' | 'set';

static: boolean;

type: 'MethodDefinition';

value: FunctionExpression;

type: 'NewExpression';

AssignmentProperty: AssignmentProperty;

CatchClause: CatchClause;

Class: Class;

ClassBody: ClassBody;

Expression: Expression;

Function: Function;

Identifier: Identifier;

Literal: Literal;

MethodDefinition: MethodDefinition;

ModuleDeclaration: ModuleDeclaration;

ModuleSpecifier: ModuleSpecifier;

Pattern: Pattern;

PrivateIdentifier: PrivateIdentifier;

Program: Program;

Property: Property;

PropertyDefinition: PropertyDefinition;

SpreadElement: SpreadElement;

Statement: Statement;

Super: Super;

SwitchCase: SwitchCase;

TemplateElement: TemplateElement;

VariableDeclarator: VariableDeclarator;

properties: Array<Property | SpreadElement>;

type: 'ObjectExpression';

properties: Array<AssignmentProperty | RestElement>;

type: 'ObjectPattern';

column: number;

line: number;

name: string;

type: 'PrivateIdentifier';

body: Array<Directive | Statement | ModuleDeclaration>;

comments?: Comment[] | undefined;

sourceType: 'script' | 'module';

type: 'Program';

computed: boolean;

key: Expression | PrivateIdentifier;

kind: 'init' | 'get' | 'set';

method: boolean;

shorthand: boolean;

type: 'Property';

value: Expression | Pattern;

computed: boolean;

key: Expression | PrivateIdentifier;

static: boolean;

type: 'PropertyDefinition';

value?: Expression | null | undefined;

raw?: string | undefined;

regex: {
    pattern: string;
    flags: string;
};

type: 'Literal';

value?: RegExp | null | undefined;

argument: Pattern;

type: 'RestElement';

argument?: Expression | null | undefined;

type: 'ReturnStatement';

expressions: Expression[];

type: 'SequenceExpression';

optional: boolean;

type: 'CallExpression';

raw?: string | undefined;

type: 'Literal';

value: string | boolean | number | null;

end: Position;

source?: string | null | undefined;

start: Position;

argument: Expression;

type: 'SpreadElement';

type: 'StaticBlock';

type: 'Super';

consequent: Statement[];

test?: Expression | null | undefined;

type: 'SwitchCase';

cases: SwitchCase[];

discriminant: Expression;

type: 'SwitchStatement';

quasi: TemplateLiteral;

tag: Expression;

type: 'TaggedTemplateExpression';

tail: boolean;

type: 'TemplateElement';

value: {
    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
    cooked?: string | null | undefined;
    raw: string;
};

expressions: Expression[];

quasis: TemplateElement[];

type: 'TemplateLiteral';

type: 'ThisExpression';