vue-eslint-parser

constructor(
    message: string,
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
);

code?: ErrorCode;

column: number;

index: number;

lineNumber: number;

static fromCode: (
    code: ErrorCode,
    offset: number,
    line: number,
    column: number
) => ParseError;

static isParseError: (x: any) => x is ParseError;

static normalize: (x: any) => ParseError | null;

elements: (ESLintExpression | ESLintSpreadElement)[];

type: 'ArrayExpression';

elements: ESLintPattern[];

type: 'ArrayPattern';

async: boolean;

body: ESLintBlockStatement | ESLintExpression;

generator: boolean;

id: ESLintIdentifier | null;

params: ESLintPattern[];

type: 'ArrowFunctionExpression';

left: ESLintPattern;

operator:
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '**='
    | '<<='
    | '>>='
    | '>>>='
    | '|='
    | '^='
    | '&='
    | '||='
    | '&&='
    | '??=';

right: ESLintExpression;

type: 'AssignmentExpression';

left: ESLintPattern;

right: ESLintExpression;

type: 'AssignmentPattern';

kind: 'init';

method: false;

value: ESLintPattern;

argument: ESLintExpression;

type: 'AwaitExpression';

bigint: string;

regex?: undefined;

value: null | bigint;

left: ESLintExpression | ESLintPrivateIdentifier;

operator:
    | '=='
    | '!='
    | '==='
    | '!=='
    | '<'
    | '<='
    | '>'
    | '>='
    | '<<'
    | '>>'
    | '>>>'
    | '+'
    | '-'
    | '*'
    | '/'
    | '%'
    | '**'
    | '|'
    | '^'
    | '&'
    | 'in'
    | 'instanceof';

right: ESLintExpression;

type: 'BinaryExpression';

body: ESLintStatement[];

type: 'BlockStatement';

bigint?: undefined;

regex?: undefined;

value: boolean;

label: ESLintIdentifier | null;

type: 'BreakStatement';

arguments: (ESLintExpression | ESLintSpreadElement)[];

callee: ESLintExpression | ESLintSuper;

optional: boolean;

type: 'CallExpression';

body: ESLintBlockStatement;

param: ESLintPattern | null;

type: 'CatchClause';

expression: ESLintChainElement;

type: 'ChainExpression';

body: (ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock)[];

type: 'ClassBody';

body: ESLintClassBody;

id: ESLintIdentifier | null;

superClass: ESLintExpression | null;

type: 'ClassDeclaration';

body: ESLintClassBody;

id: ESLintIdentifier | null;

superClass: ESLintExpression | null;

type: 'ClassExpression';

alternate: ESLintExpression;

consequent: ESLintExpression;

test: ESLintExpression;

type: 'ConditionalExpression';

label: ESLintIdentifier | null;

type: 'ContinueStatement';

type: 'DebuggerStatement';

body: ESLintStatement;

test: ESLintExpression;

type: 'DoWhileStatement';

type: 'EmptyStatement';

exported: ESLintIdentifier | ESLintStringLiteral | null;

source: ESLintLiteral;

type: 'ExportAllDeclaration';

declaration: ESLintDeclaration | ESLintExpression;

type: 'ExportDefaultDeclaration';

declaration?: ESLintDeclaration | null;

source?: ESLintLiteral | null;

specifiers: ESLintExportSpecifier[];

type: 'ExportNamedDeclaration';

exported: ESLintIdentifier | ESLintStringLiteral;

local: ESLintIdentifier | ESLintStringLiteral;

type: 'ExportSpecifier';

expression: ESLintExpression;

type: 'ExpressionStatement';

ast: ESLintProgram;

scopeManager?: ScopeManager;

services?: {};

visitorKeys?: {
    [type: string]: string[];
};

body: ESLintStatement;

left: ESLintVariableDeclaration | ESLintPattern;

right: ESLintExpression;

type: 'ForInStatement';

await: boolean;

body: ESLintStatement;

left: ESLintVariableDeclaration | ESLintPattern;

right: ESLintExpression;

type: 'ForOfStatement';

body: ESLintStatement;

init: ESLintVariableDeclaration | ESLintExpression | null;

test: ESLintExpression | null;

type: 'ForStatement';

update: ESLintExpression | null;

async: boolean;

body: ESLintBlockStatement;

generator: boolean;

id: ESLintIdentifier | null;

params: ESLintPattern[];

type: 'FunctionDeclaration';

async: boolean;

body: ESLintBlockStatement;

generator: boolean;

id: ESLintIdentifier | null;

params: ESLintPattern[];

type: 'FunctionExpression';

name: string;

type: 'Identifier';

alternate: ESLintStatement | null;

consequent: ESLintStatement;

test: ESLintExpression;

type: 'IfStatement';

source: ESLintLiteral;

specifiers: (
    | ESLintImportSpecifier
    | ESLintImportDefaultSpecifier
    | ESLintImportNamespaceSpecifier
)[];

type: 'ImportDeclaration';

local: ESLintIdentifier;

type: 'ImportDefaultSpecifier';

source: ESLintExpression;

type: 'ImportExpression';

local: ESLintIdentifier;

type: 'ImportNamespaceSpecifier';

imported: ESLintIdentifier | ESLintStringLiteral;

local: ESLintIdentifier;

type: 'ImportSpecifier';

body: ESLintStatement;

label: ESLintIdentifier;

type: 'LabeledStatement';

argument: ESLintPattern;

type: 'RestProperty' | 'ExperimentalRestProperty';

argument: ESLintExpression;

type: 'SpreadProperty' | 'ExperimentalSpreadProperty';

left: ESLintExpression;

operator: '||' | '&&' | '??';

right: ESLintExpression;

type: 'LogicalExpression';

computed: boolean;

object: ESLintExpression | ESLintSuper;

optional: boolean;

property: ESLintExpression | ESLintPrivateIdentifier;

type: 'MemberExpression';

meta: ESLintIdentifier;

property: ESLintIdentifier;

type: 'MetaProperty';

computed: boolean;

key: ESLintExpression | ESLintPrivateIdentifier;

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

static: boolean;

type: 'MethodDefinition';

value: ESLintFunctionExpression;

arguments: (ESLintExpression | ESLintSpreadElement)[];

callee: ESLintExpression;

type: 'NewExpression';

bigint?: undefined;

regex?: undefined;

value: null;

bigint?: undefined;

regex?: undefined;

value: number;

properties: (
    | ESLintProperty
    | ESLintSpreadElement
    | ESLintLegacySpreadProperty
)[];

type: 'ObjectExpression';

properties: (
    | ESLintAssignmentProperty
    | ESLintRestElement
    | ESLintLegacyRestProperty
)[];

type: 'ObjectPattern';

name: string;

type: 'PrivateIdentifier';

body: (ESLintStatement | ESLintModuleDeclaration)[];

comments?: Token[];

errors?: ParseError[];

sourceType: 'script' | 'module';

templateBody?: VElement & HasConcreteInfo;

tokens?: Token[];

type: 'Program';

computed: boolean;

key: ESLintExpression;

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

method: boolean;

shorthand: boolean;

type: 'Property';

value: ESLintExpression | ESLintPattern;

computed: boolean;

key: ESLintExpression | ESLintPrivateIdentifier;

static: boolean;

type: 'PropertyDefinition';

value: ESLintExpression | null;

bigint?: undefined;

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

value: null | RegExp;

argument: ESLintPattern;

type: 'RestElement';

argument: ESLintExpression | null;

type: 'ReturnStatement';

expressions: ESLintExpression[];

type: 'SequenceExpression';

argument: ESLintExpression;

type: 'SpreadElement';

body: ESLintStatement[];

type: 'StaticBlock';

bigint?: undefined;

regex?: undefined;

value: string;

type: 'Super';

consequent: ESLintStatement[];

test: ESLintExpression | null;

type: 'SwitchCase';

cases: ESLintSwitchCase[];

discriminant: ESLintExpression;

type: 'SwitchStatement';

quasi: ESLintTemplateLiteral;

tag: ESLintExpression;

type: 'TaggedTemplateExpression';

tail: boolean;

type: 'TemplateElement';

value: {
    cooked: string | null;
    raw: string;
};

expressions: ESLintExpression[];

quasis: ESLintTemplateElement[];

type: 'TemplateLiteral';

type: 'ThisExpression';

argument: ESLintExpression;

type: 'ThrowStatement';

block: ESLintBlockStatement;

finalizer: ESLintBlockStatement | null;

handler: ESLintCatchClause | null;

type: 'TryStatement';

argument: ESLintExpression;

operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';