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

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