.config/coc/extensions/node_modules/coc-prettier/node_modules/vue-eslint-parser/index.d.ts

   1 // Generated by dts-bundle v0.7.3
   2 // Dependencies for this module:
   3 //   ../eslint-scope
   4 //   ../eslint-visitor-keys
   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