1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | declare module 'vue-eslint-parser' {
|
7 | import * as AST from "vue-eslint-parser/ast";
|
8 | export function parseForESLint(code: string, options: any): AST.ESLintExtendedProgram;
|
9 | export function parse(code: string, options: any): AST.ESLintProgram;
|
10 | export { AST };
|
11 | }
|
12 |
|
13 | declare module 'vue-eslint-parser/ast' {
|
14 | export * from "vue-eslint-parser/ast/errors";
|
15 | export * from "vue-eslint-parser/ast/locations";
|
16 | export * from "vue-eslint-parser/ast/nodes";
|
17 | export * from "vue-eslint-parser/ast/tokens";
|
18 | export * from "vue-eslint-parser/ast/traverse";
|
19 | }
|
20 |
|
21 | declare module 'vue-eslint-parser/ast/errors' {
|
22 | export class ParseError extends SyntaxError {
|
23 | code?: ErrorCode;
|
24 | index: number;
|
25 | lineNumber: number;
|
26 | column: number;
|
27 | static fromCode(code: ErrorCode, offset: number, line: number, column: number): ParseError;
|
28 | static normalize(x: any): ParseError | null;
|
29 | constructor(message: string, code: ErrorCode | undefined, offset: number, line: number, column: number);
|
30 | static isParseError(x: any): x is ParseError;
|
31 | }
|
32 | export type ErrorCode = "abrupt-closing-of-empty-comment" | "absence-of-digits-in-numeric-character-reference" | "cdata-in-html-content" | "character-reference-outside-unicode-range" | "control-character-in-input-stream" | "control-character-reference" | "eof-before-tag-name" | "eof-in-cdata" | "eof-in-comment" | "eof-in-tag" | "incorrectly-closed-comment" | "incorrectly-opened-comment" | "invalid-first-character-of-tag-name" | "missing-attribute-value" | "missing-end-tag-name" | "missing-semicolon-after-character-reference" | "missing-whitespace-between-attributes" | "nested-comment" | "noncharacter-character-reference" | "noncharacter-in-input-stream" | "null-character-reference" | "surrogate-character-reference" | "surrogate-in-input-stream" | "unexpected-character-in-attribute-name" | "unexpected-character-in-unquoted-attribute-value" | "unexpected-equals-sign-before-attribute-name" | "unexpected-null-character" | "unexpected-question-mark-instead-of-tag-name" | "unexpected-solidus-in-tag" | "unknown-named-character-reference" | "end-tag-with-attributes" | "duplicate-attribute" | "end-tag-with-trailing-solidus" | "non-void-html-element-start-tag-with-trailing-solidus" | "x-invalid-end-tag" | "x-invalid-namespace";
|
33 | }
|
34 |
|
35 | declare module 'vue-eslint-parser/ast/locations' {
|
36 | export interface Location {
|
37 | line: number;
|
38 | column: number;
|
39 | }
|
40 | export interface LocationRange {
|
41 | start: Location;
|
42 | end: Location;
|
43 | }
|
44 | export type Offset = number;
|
45 | export type OffsetRange = [Offset, Offset];
|
46 | export interface HasLocation {
|
47 | range: OffsetRange;
|
48 | loc: LocationRange;
|
49 | start?: number;
|
50 | end?: number;
|
51 | }
|
52 | }
|
53 |
|
54 | declare module 'vue-eslint-parser/ast/nodes' {
|
55 | import { ScopeManager } from "eslint-scope";
|
56 | import { ParseError } from "vue-eslint-parser/ast/errors";
|
57 | import { HasLocation } from "vue-eslint-parser/ast/locations";
|
58 | import { Token } from "vue-eslint-parser/ast/tokens";
|
59 | export interface HasParent {
|
60 | parent?: Node | null;
|
61 | }
|
62 | export type Node = ESLintNode | VNode | VForExpression | VOnExpression | VSlotScopeExpression | VFilterSequenceExpression | VFilter;
|
63 | export type ESLintNode = ESLintIdentifier | ESLintLiteral | ESLintProgram | ESLintSwitchCase | ESLintCatchClause | ESLintVariableDeclarator | ESLintStatement | ESLintExpression | ESLintProperty | ESLintAssignmentProperty | ESLintSuper | ESLintTemplateElement | ESLintSpreadElement | ESLintPattern | ESLintClassBody | ESLintMethodDefinition | ESLintModuleDeclaration | ESLintModuleSpecifier | ESLintLegacyRestProperty;
|
64 | export interface ESLintExtendedProgram {
|
65 | ast: ESLintProgram;
|
66 | services?: {};
|
67 | visitorKeys?: {
|
68 | [type: string]: string[];
|
69 | };
|
70 | scopeManager?: ScopeManager;
|
71 | }
|
72 | export interface ESLintProgram extends HasLocation, HasParent {
|
73 | type: "Program";
|
74 | sourceType: "script" | "module";
|
75 | body: (ESLintStatement | ESLintModuleDeclaration)[];
|
76 | templateBody?: VElement & HasConcreteInfo;
|
77 | tokens?: Token[];
|
78 | comments?: Token[];
|
79 | errors?: ParseError[];
|
80 | }
|
81 | export type ESLintStatement = ESLintExpressionStatement | ESLintBlockStatement | ESLintEmptyStatement | ESLintDebuggerStatement | ESLintWithStatement | ESLintReturnStatement | ESLintLabeledStatement | ESLintBreakStatement | ESLintContinueStatement | ESLintIfStatement | ESLintSwitchStatement | ESLintThrowStatement | ESLintTryStatement | ESLintWhileStatement | ESLintDoWhileStatement | ESLintForStatement | ESLintForInStatement | ESLintForOfStatement | ESLintDeclaration;
|
82 | export interface ESLintEmptyStatement extends HasLocation, HasParent {
|
83 | type: "EmptyStatement";
|
84 | }
|
85 | export interface ESLintBlockStatement extends HasLocation, HasParent {
|
86 | type: "BlockStatement";
|
87 | body: ESLintStatement[];
|
88 | }
|
89 | export interface ESLintExpressionStatement extends HasLocation, HasParent {
|
90 | type: "ExpressionStatement";
|
91 | expression: ESLintExpression;
|
92 | }
|
93 | export interface ESLintIfStatement extends HasLocation, HasParent {
|
94 | type: "IfStatement";
|
95 | test: ESLintExpression;
|
96 | consequent: ESLintStatement;
|
97 | alternate: ESLintStatement | null;
|
98 | }
|
99 | export interface ESLintSwitchStatement extends HasLocation, HasParent {
|
100 | type: "SwitchStatement";
|
101 | discriminant: ESLintExpression;
|
102 | cases: ESLintSwitchCase[];
|
103 | }
|
104 | export interface ESLintSwitchCase extends HasLocation, HasParent {
|
105 | type: "SwitchCase";
|
106 | test: ESLintExpression | null;
|
107 | consequent: ESLintStatement[];
|
108 | }
|
109 | export interface ESLintWhileStatement extends HasLocation, HasParent {
|
110 | type: "WhileStatement";
|
111 | test: ESLintExpression;
|
112 | body: ESLintStatement;
|
113 | }
|
114 | export interface ESLintDoWhileStatement extends HasLocation, HasParent {
|
115 | type: "DoWhileStatement";
|
116 | body: ESLintStatement;
|
117 | test: ESLintExpression;
|
118 | }
|
119 | export interface ESLintForStatement extends HasLocation, HasParent {
|
120 | type: "ForStatement";
|
121 | init: ESLintVariableDeclaration | ESLintExpression | null;
|
122 | test: ESLintExpression | null;
|
123 | update: ESLintExpression | null;
|
124 | body: ESLintStatement;
|
125 | }
|
126 | export interface ESLintForInStatement extends HasLocation, HasParent {
|
127 | type: "ForInStatement";
|
128 | left: ESLintVariableDeclaration | ESLintPattern;
|
129 | right: ESLintExpression;
|
130 | body: ESLintStatement;
|
131 | }
|
132 | export interface ESLintForOfStatement extends HasLocation, HasParent {
|
133 | type: "ForOfStatement";
|
134 | left: ESLintVariableDeclaration | ESLintPattern;
|
135 | right: ESLintExpression;
|
136 | body: ESLintStatement;
|
137 | }
|
138 | export interface ESLintLabeledStatement extends HasLocation, HasParent {
|
139 | type: "LabeledStatement";
|
140 | label: ESLintIdentifier;
|
141 | body: ESLintStatement;
|
142 | }
|
143 | export interface ESLintBreakStatement extends HasLocation, HasParent {
|
144 | type: "BreakStatement";
|
145 | label: ESLintIdentifier | null;
|
146 | }
|
147 | export interface ESLintContinueStatement extends HasLocation, HasParent {
|
148 | type: "ContinueStatement";
|
149 | label: ESLintIdentifier | null;
|
150 | }
|
151 | export interface ESLintReturnStatement extends HasLocation, HasParent {
|
152 | type: "ReturnStatement";
|
153 | argument: ESLintExpression | null;
|
154 | }
|
155 | export interface ESLintThrowStatement extends HasLocation, HasParent {
|
156 | type: "ThrowStatement";
|
157 | argument: ESLintExpression;
|
158 | }
|
159 | export interface ESLintTryStatement extends HasLocation, HasParent {
|
160 | type: "TryStatement";
|
161 | block: ESLintBlockStatement;
|
162 | handler: ESLintCatchClause | null;
|
163 | finalizer: ESLintBlockStatement | null;
|
164 | }
|
165 | export interface ESLintCatchClause extends HasLocation, HasParent {
|
166 | type: "CatchClause";
|
167 | param: ESLintPattern;
|
168 | body: ESLintBlockStatement;
|
169 | }
|
170 | export interface ESLintWithStatement extends HasLocation, HasParent {
|
171 | type: "WithStatement";
|
172 | object: ESLintExpression;
|
173 | body: ESLintStatement;
|
174 | }
|
175 | export interface ESLintDebuggerStatement extends HasLocation, HasParent {
|
176 | type: "DebuggerStatement";
|
177 | }
|
178 | export type ESLintDeclaration = ESLintFunctionDeclaration | ESLintVariableDeclaration | ESLintClassDeclaration;
|
179 | export interface ESLintFunctionDeclaration extends HasLocation, HasParent {
|
180 | type: "FunctionDeclaration";
|
181 | async: boolean;
|
182 | generator: boolean;
|
183 | id: ESLintIdentifier | null;
|
184 | params: ESLintPattern[];
|
185 | body: ESLintBlockStatement;
|
186 | }
|
187 | export interface ESLintVariableDeclaration extends HasLocation, HasParent {
|
188 | type: "VariableDeclaration";
|
189 | kind: "var" | "let" | "const";
|
190 | declarations: ESLintVariableDeclarator[];
|
191 | }
|
192 | export interface ESLintVariableDeclarator extends HasLocation, HasParent {
|
193 | type: "VariableDeclarator";
|
194 | id: ESLintPattern;
|
195 | init: ESLintExpression | null;
|
196 | }
|
197 | export interface ESLintClassDeclaration extends HasLocation, HasParent {
|
198 | type: "ClassDeclaration";
|
199 | id: ESLintIdentifier | null;
|
200 | superClass: ESLintExpression | null;
|
201 | body: ESLintClassBody;
|
202 | }
|
203 | export interface ESLintClassBody extends HasLocation, HasParent {
|
204 | type: "ClassBody";
|
205 | body: ESLintMethodDefinition[];
|
206 | }
|
207 | export interface ESLintMethodDefinition extends HasLocation, HasParent {
|
208 | type: "MethodDefinition";
|
209 | kind: "constructor" | "method" | "get" | "set";
|
210 | computed: boolean;
|
211 | static: boolean;
|
212 | key: ESLintExpression;
|
213 | value: ESLintFunctionExpression;
|
214 | }
|
215 | export type ESLintModuleDeclaration = ESLintImportDeclaration | ESLintExportNamedDeclaration | ESLintExportDefaultDeclaration | ESLintExportAllDeclaration;
|
216 | export type ESLintModuleSpecifier = ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier | ESLintExportSpecifier;
|
217 | export interface ESLintImportDeclaration extends HasLocation, HasParent {
|
218 | type: "ImportDeclaration";
|
219 | specifiers: (ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier)[];
|
220 | source: ESLintLiteral;
|
221 | }
|
222 | export interface ESLintImportSpecifier extends HasLocation, HasParent {
|
223 | type: "ImportSpecifier";
|
224 | imported: ESLintIdentifier;
|
225 | local: ESLintIdentifier;
|
226 | }
|
227 | export interface ESLintImportDefaultSpecifier extends HasLocation, HasParent {
|
228 | type: "ImportDefaultSpecifier";
|
229 | local: ESLintIdentifier;
|
230 | }
|
231 | export interface ESLintImportNamespaceSpecifier extends HasLocation, HasParent {
|
232 | type: "ImportNamespaceSpecifier";
|
233 | local: ESLintIdentifier;
|
234 | }
|
235 | export interface ESLintExportNamedDeclaration extends HasLocation, HasParent {
|
236 | type: "ExportNamedDeclaration";
|
237 | declaration?: ESLintDeclaration | null;
|
238 | specifiers: ESLintExportSpecifier[];
|
239 | source?: ESLintLiteral | null;
|
240 | }
|
241 | export interface ESLintExportSpecifier extends HasLocation, HasParent {
|
242 | type: "ExportSpecifier";
|
243 | exported: ESLintIdentifier;
|
244 | }
|
245 | export interface ESLintExportDefaultDeclaration extends HasLocation, HasParent {
|
246 | type: "ExportDefaultDeclaration";
|
247 | declaration: ESLintDeclaration | ESLintExpression;
|
248 | }
|
249 | export interface ESLintExportAllDeclaration extends HasLocation, HasParent {
|
250 | type: "ExportAllDeclaration";
|
251 | source: ESLintLiteral;
|
252 | }
|
253 | export type ESLintExpression = ESLintThisExpression | ESLintArrayExpression | ESLintObjectExpression | ESLintFunctionExpression | ESLintArrowFunctionExpression | ESLintYieldExpression | ESLintLiteral | ESLintUnaryExpression | ESLintUpdateExpression | ESLintBinaryExpression | ESLintAssignmentExpression | ESLintLogicalExpression | ESLintMemberExpression | ESLintConditionalExpression | ESLintCallExpression | ESLintNewExpression | ESLintSequenceExpression | ESLintTemplateLiteral | ESLintTaggedTemplateExpression | ESLintClassExpression | ESLintMetaProperty | ESLintIdentifier | ESLintAwaitExpression;
|
254 | export interface ESLintIdentifier extends HasLocation, HasParent {
|
255 | type: "Identifier";
|
256 | name: string;
|
257 | }
|
258 | export interface ESLintLiteral extends HasLocation, HasParent {
|
259 | type: "Literal";
|
260 | value: string | boolean | null | number | RegExp;
|
261 | regex?: {
|
262 | pattern: string;
|
263 | flags: string;
|
264 | };
|
265 | }
|
266 | export interface ESLintThisExpression extends HasLocation, HasParent {
|
267 | type: "ThisExpression";
|
268 | }
|
269 | export interface ESLintArrayExpression extends HasLocation, HasParent {
|
270 | type: "ArrayExpression";
|
271 | elements: (ESLintExpression | ESLintSpreadElement)[];
|
272 | }
|
273 | export interface ESLintObjectExpression extends HasLocation, HasParent {
|
274 | type: "ObjectExpression";
|
275 | properties: (ESLintProperty | ESLintSpreadElement | ESLintLegacySpreadProperty)[];
|
276 | }
|
277 | export interface ESLintProperty extends HasLocation, HasParent {
|
278 | type: "Property";
|
279 | kind: "init" | "get" | "set";
|
280 | method: boolean;
|
281 | shorthand: boolean;
|
282 | computed: boolean;
|
283 | key: ESLintExpression;
|
284 | value: ESLintExpression | ESLintPattern;
|
285 | }
|
286 | export interface ESLintFunctionExpression extends HasLocation, HasParent {
|
287 | type: "FunctionExpression";
|
288 | async: boolean;
|
289 | generator: boolean;
|
290 | id: ESLintIdentifier | null;
|
291 | params: ESLintPattern[];
|
292 | body: ESLintBlockStatement;
|
293 | }
|
294 | export interface ESLintArrowFunctionExpression extends HasLocation, HasParent {
|
295 | type: "ArrowFunctionExpression";
|
296 | async: boolean;
|
297 | generator: boolean;
|
298 | id: ESLintIdentifier | null;
|
299 | params: ESLintPattern[];
|
300 | body: ESLintBlockStatement;
|
301 | }
|
302 | export interface ESLintSequenceExpression extends HasLocation, HasParent {
|
303 | type: "SequenceExpression";
|
304 | expressions: ESLintExpression[];
|
305 | }
|
306 | export interface ESLintUnaryExpression extends HasLocation, HasParent {
|
307 | type: "UnaryExpression";
|
308 | operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
|
309 | prefix: boolean;
|
310 | argument: ESLintExpression;
|
311 | }
|
312 | export interface ESLintBinaryExpression extends HasLocation, HasParent {
|
313 | type: "BinaryExpression";
|
314 | operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
|
315 | left: ESLintExpression;
|
316 | right: ESLintExpression;
|
317 | }
|
318 | export interface ESLintAssignmentExpression extends HasLocation, HasParent {
|
319 | type: "AssignmentExpression";
|
320 | operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
|
321 | left: ESLintPattern;
|
322 | right: ESLintExpression;
|
323 | }
|
324 | export interface ESLintUpdateExpression extends HasLocation, HasParent {
|
325 | type: "UpdateExpression";
|
326 | operator: "++" | "--";
|
327 | argument: ESLintExpression;
|
328 | prefix: boolean;
|
329 | }
|
330 | export interface ESLintLogicalExpression extends HasLocation, HasParent {
|
331 | type: "LogicalExpression";
|
332 | operator: "||" | "&&";
|
333 | left: ESLintExpression;
|
334 | right: ESLintExpression;
|
335 | }
|
336 | export interface ESLintConditionalExpression extends HasLocation, HasParent {
|
337 | type: "ConditionalExpression";
|
338 | test: ESLintExpression;
|
339 | alternate: ESLintExpression;
|
340 | consequent: ESLintExpression;
|
341 | }
|
342 | export interface ESLintCallExpression extends HasLocation, HasParent {
|
343 | type: "CallExpression";
|
344 | callee: ESLintExpression | ESLintSuper;
|
345 | arguments: (ESLintExpression | ESLintSpreadElement)[];
|
346 | }
|
347 | export interface ESLintSuper extends HasLocation, HasParent {
|
348 | type: "Super";
|
349 | }
|
350 | export interface ESLintNewExpression extends HasLocation, HasParent {
|
351 | type: "NewExpression";
|
352 | callee: ESLintExpression;
|
353 | arguments: (ESLintExpression | ESLintSpreadElement)[];
|
354 | }
|
355 | export interface ESLintMemberExpression extends HasLocation, HasParent {
|
356 | type: "MemberExpression";
|
357 | computed: boolean;
|
358 | object: ESLintExpression | ESLintSuper;
|
359 | property: ESLintExpression;
|
360 | }
|
361 | export interface ESLintYieldExpression extends HasLocation, HasParent {
|
362 | type: "YieldExpression";
|
363 | delegate: boolean;
|
364 | argument: ESLintExpression | null;
|
365 | }
|
366 | export interface ESLintAwaitExpression extends HasLocation, HasParent {
|
367 | type: "AwaitExpression";
|
368 | argument: ESLintExpression;
|
369 | }
|
370 | export interface ESLintTemplateLiteral extends HasLocation, HasParent {
|
371 | type: "TemplateLiteral";
|
372 | quasis: ESLintTemplateElement[];
|
373 | expressions: ESLintExpression[];
|
374 | }
|
375 | export interface ESLintTaggedTemplateExpression extends HasLocation, HasParent {
|
376 | type: "TaggedTemplateExpression";
|
377 | tag: ESLintExpression;
|
378 | quasi: ESLintTemplateLiteral;
|
379 | }
|
380 | export interface ESLintTemplateElement extends HasLocation, HasParent {
|
381 | type: "TemplateElement";
|
382 | tail: boolean;
|
383 | value: {
|
384 | cooked: string;
|
385 | raw: string;
|
386 | };
|
387 | }
|
388 | export interface ESLintClassExpression extends HasLocation, HasParent {
|
389 | type: "ClassExpression";
|
390 | id: ESLintIdentifier | null;
|
391 | superClass: ESLintExpression | null;
|
392 | body: ESLintClassBody;
|
393 | }
|
394 | export interface ESLintMetaProperty extends HasLocation, HasParent {
|
395 | type: "MetaProperty";
|
396 | meta: ESLintIdentifier;
|
397 | property: ESLintIdentifier;
|
398 | }
|
399 | export type ESLintPattern = ESLintIdentifier | ESLintObjectPattern | ESLintArrayPattern | ESLintRestElement | ESLintAssignmentPattern | ESLintMemberExpression | ESLintLegacyRestProperty;
|
400 | export interface ESLintObjectPattern extends HasLocation, HasParent {
|
401 | type: "ObjectPattern";
|
402 | properties: (ESLintAssignmentProperty | ESLintRestElement | ESLintLegacyRestProperty)[];
|
403 | }
|
404 | export interface ESLintAssignmentProperty extends ESLintProperty {
|
405 | value: ESLintPattern;
|
406 | kind: "init";
|
407 | method: false;
|
408 | }
|
409 | export interface ESLintArrayPattern extends HasLocation, HasParent {
|
410 | type: "ArrayPattern";
|
411 | elements: ESLintPattern[];
|
412 | }
|
413 | export interface ESLintRestElement extends HasLocation, HasParent {
|
414 | type: "RestElement";
|
415 | argument: ESLintPattern;
|
416 | }
|
417 | export interface ESLintSpreadElement extends HasLocation, HasParent {
|
418 | type: "SpreadElement";
|
419 | argument: ESLintExpression;
|
420 | }
|
421 | export interface ESLintAssignmentPattern extends HasLocation, HasParent {
|
422 | type: "AssignmentPattern";
|
423 | left: ESLintPattern;
|
424 | right: ESLintExpression;
|
425 | }
|
426 | export interface ESLintLegacyRestProperty extends HasLocation, HasParent {
|
427 | type: "RestProperty" | "ExperimentalRestProperty";
|
428 | argument: ESLintPattern;
|
429 | }
|
430 | export interface ESLintLegacySpreadProperty extends HasLocation, HasParent {
|
431 | type: "SpreadProperty" | "ExperimentalSpreadProperty";
|
432 | argument: ESLintExpression;
|
433 | }
|
434 | export const NS: Readonly<{
|
435 | HTML: "http://www.w3.org/1999/xhtml";
|
436 | MathML: "http://www.w3.org/1998/Math/MathML";
|
437 | SVG: "http://www.w3.org/2000/svg";
|
438 | XLink: "http://www.w3.org/1999/xlink";
|
439 | XML: "http://www.w3.org/XML/1998/namespace";
|
440 | XMLNS: "http://www.w3.org/2000/xmlns/";
|
441 | }>;
|
442 | export type Namespace = typeof NS.HTML | typeof NS.MathML | typeof NS.SVG | typeof NS.XLink | typeof NS.XML | typeof NS.XMLNS;
|
443 | export interface Variable {
|
444 | id: ESLintIdentifier;
|
445 | kind: "v-for" | "scope";
|
446 | references: Reference[];
|
447 | }
|
448 | export interface Reference {
|
449 | id: ESLintIdentifier;
|
450 | mode: "rw" | "r" | "w";
|
451 | variable: Variable | null;
|
452 | }
|
453 | export interface VForExpression extends HasLocation, HasParent {
|
454 | type: "VForExpression";
|
455 | parent: VExpressionContainer;
|
456 | left: ESLintPattern[];
|
457 | right: ESLintExpression;
|
458 | }
|
459 | export interface VOnExpression extends HasLocation, HasParent {
|
460 | type: "VOnExpression";
|
461 | parent: VExpressionContainer;
|
462 | body: ESLintStatement[];
|
463 | }
|
464 | export interface VSlotScopeExpression extends HasLocation, HasParent {
|
465 | type: "VSlotScopeExpression";
|
466 | parent: VExpressionContainer;
|
467 | params: ESLintPattern[];
|
468 | }
|
469 | export interface VFilterSequenceExpression extends HasLocation, HasParent {
|
470 | type: "VFilterSequenceExpression";
|
471 | parent: VExpressionContainer;
|
472 | expression: ESLintExpression;
|
473 | filters: VFilter[];
|
474 | }
|
475 | export interface VFilter extends HasLocation, HasParent {
|
476 | type: "VFilter";
|
477 | parent: VFilterSequenceExpression;
|
478 | callee: ESLintIdentifier;
|
479 | arguments: (ESLintExpression | ESLintSpreadElement)[];
|
480 | }
|
481 | export type VNode = VAttribute | VDirective | VDirectiveKey | VDocumentFragment | VElement | VEndTag | VExpressionContainer | VIdentifier | VLiteral | VStartTag | VText;
|
482 | export interface VText extends HasLocation, HasParent {
|
483 | type: "VText";
|
484 | parent: VDocumentFragment | VElement;
|
485 | value: string;
|
486 | }
|
487 | export interface VExpressionContainer extends HasLocation, HasParent {
|
488 | type: "VExpressionContainer";
|
489 | parent: VDocumentFragment | VElement | VDirective | VDirectiveKey;
|
490 | expression: ESLintExpression | VFilterSequenceExpression | VForExpression | VOnExpression | VSlotScopeExpression | null;
|
491 | references: Reference[];
|
492 | }
|
493 | export interface VIdentifier extends HasLocation, HasParent {
|
494 | type: "VIdentifier";
|
495 | parent: VAttribute | VDirectiveKey;
|
496 | name: string;
|
497 | rawName: string;
|
498 | }
|
499 | export interface VDirectiveKey extends HasLocation, HasParent {
|
500 | type: "VDirectiveKey";
|
501 | parent: VAttribute;
|
502 | name: VIdentifier;
|
503 | argument: VExpressionContainer | VIdentifier | null;
|
504 | modifiers: VIdentifier[];
|
505 | }
|
506 | export interface VLiteral extends HasLocation, HasParent {
|
507 | type: "VLiteral";
|
508 | parent: VAttribute;
|
509 | value: string;
|
510 | }
|
511 | export interface VAttribute extends HasLocation, HasParent {
|
512 | type: "VAttribute";
|
513 | parent: VStartTag;
|
514 | directive: false;
|
515 | key: VIdentifier;
|
516 | value: VLiteral | null;
|
517 | }
|
518 | export interface VDirective extends HasLocation, HasParent {
|
519 | type: "VAttribute";
|
520 | parent: VStartTag;
|
521 | directive: true;
|
522 | key: VDirectiveKey;
|
523 | value: VExpressionContainer | null;
|
524 | }
|
525 | export interface VStartTag extends HasLocation, HasParent {
|
526 | type: "VStartTag";
|
527 | parent: VElement;
|
528 | selfClosing: boolean;
|
529 | attributes: (VAttribute | VDirective)[];
|
530 | }
|
531 | export interface VEndTag extends HasLocation, HasParent {
|
532 | type: "VEndTag";
|
533 | parent: VElement;
|
534 | }
|
535 | export interface HasConcreteInfo {
|
536 | tokens: Token[];
|
537 | comments: Token[];
|
538 | errors: ParseError[];
|
539 | }
|
540 | export interface VElement extends HasLocation, HasParent {
|
541 | type: "VElement";
|
542 | parent: VDocumentFragment | VElement;
|
543 | namespace: Namespace;
|
544 | name: string;
|
545 | rawName: string;
|
546 | startTag: VStartTag;
|
547 | children: (VElement | VText | VExpressionContainer)[];
|
548 | endTag: VEndTag | null;
|
549 | variables: Variable[];
|
550 | }
|
551 | export interface VDocumentFragment extends HasLocation, HasParent, HasConcreteInfo {
|
552 | type: "VDocumentFragment";
|
553 | parent: null;
|
554 | children: (VElement | VText | VExpressionContainer)[];
|
555 | }
|
556 | }
|
557 |
|
558 | declare module 'vue-eslint-parser/ast/tokens' {
|
559 | import { HasLocation } from "vue-eslint-parser/ast/locations";
|
560 | export interface Token extends HasLocation {
|
561 | type: string;
|
562 | value: string;
|
563 | }
|
564 | }
|
565 |
|
566 | declare module 'vue-eslint-parser/ast/traverse' {
|
567 | import { VisitorKeys } from "eslint-visitor-keys";
|
568 | import { Node } from "vue-eslint-parser/ast/nodes";
|
569 | function getFallbackKeys(node: Node): string[];
|
570 | export interface Visitor {
|
571 | visitorKeys?: VisitorKeys;
|
572 | enterNode(node: Node, parent: Node | null): void;
|
573 | leaveNode(node: Node, parent: Node | null): void;
|
574 | }
|
575 | export function traverseNodes(node: Node, visitor: Visitor): void;
|
576 | export { getFallbackKeys };
|
577 | }
|
578 |
|