@vue-vine/eslint-parser 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,795 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { parseForESLint as parseForESLint$1, ParserOptions } from '@typescript-eslint/parser';
+import { ScopeManager } from 'eslint-scope';
+
+/**
+ * HTML parse errors.
+ */
+declare class ParseError extends SyntaxError {
+    code?: ErrorCode;
+    index: number;
+    lineNumber: number;
+    column: number;
+    /**
+     * Create new parser error object.
+     * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+     * @param offset The offset number of this error.
+     * @param line The line number of this error.
+     * @param column The column number of this error.
+     */
+    static fromCode(code: ErrorCode, offset: number, line: number, column: number): ParseError;
+    /**
+     * Normalize the error object.
+     * @param x The error object to normalize.
+     */
+    static normalize(x: any): ParseError | null;
+    /**
+     * Initialize this ParseError instance.
+     * @param message The error message.
+     * @param code The error code. See also: https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+     * @param offset The offset number of this error.
+     * @param line The line number of this error.
+     * @param column The column number of this error.
+     */
+    constructor(message: string, code: ErrorCode | undefined, offset: number, line: number, column: number);
+    /**
+     * Type guard for ParseError.
+     * @param x The value to check.
+     * @returns `true` if the value has `message`, `pos`, `loc` properties.
+     */
+    static isParseError(x: any): x is ParseError;
+}
+/**
+ * The error codes of HTML syntax errors.
+ * https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+ */
+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' | 'x-missing-interpolation-end';
+
+/**
+ * Location information in lines and columns.
+ */
+interface Location {
+    /**
+     * The line number. This is 1-based.
+     */
+    line: number;
+    /**
+     * The column number. This is 0-based.
+     */
+    column: number;
+}
+/**
+ * Range information in lines and columns.
+ */
+interface LocationRange {
+    /**
+     * The start location.
+     */
+    start: Location;
+    /**
+     * The end location.
+     */
+    end: Location;
+}
+/**
+ * Location information in offsets.
+ * This is 0-based.
+ */
+type Offset = number;
+/**
+ * Range information in offsets.
+ * The 1st element is the start offset.
+ * The 2nd element is the end offset.
+ *
+ * This is 0-based.
+ */
+type OffsetRange = [Offset, Offset];
+/**
+ * Objects which have their location.
+ */
+interface HasLocation {
+    range: OffsetRange;
+    loc: LocationRange;
+    start?: number;
+    end?: number;
+}
+
+/**
+ * Tokens.
+ */
+interface Token extends HasLocation {
+    /**
+     * Token types.
+     */
+    type: string;
+    /**
+     * Processed values.
+     */
+    value: string;
+}
+
+/**
+ * Objects which have their parent.
+ */
+interface HasParent {
+    parent?: Node | null;
+}
+/**
+ * The union type for all nodes.
+ */
+type Node = ESLintNode | VNode | VForExpression | VOnExpression | VSlotScopeExpression | VFilterSequenceExpression | VFilter;
+/**
+ * The union type for ESLint nodes.
+ */
+type ESLintNode = ESLintIdentifier | ESLintLiteral | ESLintProgram | ESLintSwitchCase | ESLintCatchClause | ESLintVariableDeclarator | ESLintStatement | ESLintExpression | ESLintProperty | ESLintAssignmentProperty | ESLintSuper | ESLintTemplateElement | ESLintSpreadElement | ESLintPattern | ESLintClassBody | ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock | ESLintPrivateIdentifier | ESLintModuleDeclaration | ESLintModuleSpecifier | ESLintImportExpression | ESLintLegacyRestProperty;
+/**
+ * The parsing result of ESLint custom parsers.
+ */
+interface ESLintExtendedProgram {
+    ast: ESLintProgram;
+    services?: Record<string, unknown>;
+    visitorKeys?: {
+        [type: string]: string[];
+    };
+    scopeManager?: ScopeManager;
+}
+interface ESLintProgram extends HasLocation, HasParent {
+    type: 'Program';
+    sourceType: 'script' | 'module';
+    body: (ESLintStatement | ESLintModuleDeclaration)[];
+    templateBody?: VElement & HasConcreteInfo;
+    tokens?: Token[];
+    comments?: Token[];
+    errors?: ParseError[];
+}
+type ESLintStatement = ESLintExpressionStatement | ESLintBlockStatement | ESLintEmptyStatement | ESLintDebuggerStatement | ESLintWithStatement | ESLintReturnStatement | ESLintLabeledStatement | ESLintBreakStatement | ESLintContinueStatement | ESLintIfStatement | ESLintSwitchStatement | ESLintThrowStatement | ESLintTryStatement | ESLintWhileStatement | ESLintDoWhileStatement | ESLintForStatement | ESLintForInStatement | ESLintForOfStatement | ESLintDeclaration;
+interface ESLintEmptyStatement extends HasLocation, HasParent {
+    type: 'EmptyStatement';
+}
+interface ESLintBlockStatement extends HasLocation, HasParent {
+    type: 'BlockStatement';
+    body: ESLintStatement[];
+}
+interface ESLintExpressionStatement extends HasLocation, HasParent {
+    type: 'ExpressionStatement';
+    expression: ESLintExpression;
+}
+interface ESLintIfStatement extends HasLocation, HasParent {
+    type: 'IfStatement';
+    test: ESLintExpression;
+    consequent: ESLintStatement;
+    alternate: ESLintStatement | null;
+}
+interface ESLintSwitchStatement extends HasLocation, HasParent {
+    type: 'SwitchStatement';
+    discriminant: ESLintExpression;
+    cases: ESLintSwitchCase[];
+}
+interface ESLintSwitchCase extends HasLocation, HasParent {
+    type: 'SwitchCase';
+    test: ESLintExpression | null;
+    consequent: ESLintStatement[];
+}
+interface ESLintWhileStatement extends HasLocation, HasParent {
+    type: 'WhileStatement';
+    test: ESLintExpression;
+    body: ESLintStatement;
+}
+interface ESLintDoWhileStatement extends HasLocation, HasParent {
+    type: 'DoWhileStatement';
+    body: ESLintStatement;
+    test: ESLintExpression;
+}
+interface ESLintForStatement extends HasLocation, HasParent {
+    type: 'ForStatement';
+    init: ESLintVariableDeclaration | ESLintExpression | null;
+    test: ESLintExpression | null;
+    update: ESLintExpression | null;
+    body: ESLintStatement;
+}
+interface ESLintForInStatement extends HasLocation, HasParent {
+    type: 'ForInStatement';
+    left: ESLintVariableDeclaration | ESLintPattern;
+    right: ESLintExpression;
+    body: ESLintStatement;
+}
+interface ESLintForOfStatement extends HasLocation, HasParent {
+    type: 'ForOfStatement';
+    left: ESLintVariableDeclaration | ESLintPattern;
+    right: ESLintExpression;
+    body: ESLintStatement;
+    await: boolean;
+}
+interface ESLintLabeledStatement extends HasLocation, HasParent {
+    type: 'LabeledStatement';
+    label: ESLintIdentifier;
+    body: ESLintStatement;
+}
+interface ESLintBreakStatement extends HasLocation, HasParent {
+    type: 'BreakStatement';
+    label: ESLintIdentifier | null;
+}
+interface ESLintContinueStatement extends HasLocation, HasParent {
+    type: 'ContinueStatement';
+    label: ESLintIdentifier | null;
+}
+interface ESLintReturnStatement extends HasLocation, HasParent {
+    type: 'ReturnStatement';
+    argument: ESLintExpression | null;
+}
+interface ESLintThrowStatement extends HasLocation, HasParent {
+    type: 'ThrowStatement';
+    argument: ESLintExpression;
+}
+interface ESLintTryStatement extends HasLocation, HasParent {
+    type: 'TryStatement';
+    block: ESLintBlockStatement;
+    handler: ESLintCatchClause | null;
+    finalizer: ESLintBlockStatement | null;
+}
+interface ESLintCatchClause extends HasLocation, HasParent {
+    type: 'CatchClause';
+    param: ESLintPattern | null;
+    body: ESLintBlockStatement;
+}
+interface ESLintWithStatement extends HasLocation, HasParent {
+    type: 'WithStatement';
+    object: ESLintExpression;
+    body: ESLintStatement;
+}
+interface ESLintDebuggerStatement extends HasLocation, HasParent {
+    type: 'DebuggerStatement';
+}
+type ESLintDeclaration = ESLintFunctionDeclaration | ESLintVariableDeclaration | ESLintClassDeclaration;
+interface ESLintFunctionDeclaration extends HasLocation, HasParent {
+    type: 'FunctionDeclaration';
+    async: boolean;
+    generator: boolean;
+    id: ESLintIdentifier | null;
+    params: ESLintPattern[];
+    body: ESLintBlockStatement;
+}
+interface ESLintVariableDeclaration extends HasLocation, HasParent {
+    type: 'VariableDeclaration';
+    kind: 'var' | 'let' | 'const';
+    declarations: ESLintVariableDeclarator[];
+}
+interface ESLintVariableDeclarator extends HasLocation, HasParent {
+    type: 'VariableDeclarator';
+    id: ESLintPattern;
+    init: ESLintExpression | null;
+}
+interface ESLintClassDeclaration extends HasLocation, HasParent {
+    type: 'ClassDeclaration';
+    id: ESLintIdentifier | null;
+    superClass: ESLintExpression | null;
+    body: ESLintClassBody;
+}
+interface ESLintClassBody extends HasLocation, HasParent {
+    type: 'ClassBody';
+    body: (ESLintMethodDefinition | ESLintPropertyDefinition | ESLintStaticBlock)[];
+}
+interface ESLintMethodDefinition extends HasLocation, HasParent {
+    type: 'MethodDefinition';
+    kind: 'constructor' | 'method' | 'get' | 'set';
+    computed: boolean;
+    static: boolean;
+    key: ESLintExpression | ESLintPrivateIdentifier;
+    value: ESLintFunctionExpression;
+}
+interface ESLintPropertyDefinition extends HasLocation, HasParent {
+    type: 'PropertyDefinition';
+    computed: boolean;
+    static: boolean;
+    key: ESLintExpression | ESLintPrivateIdentifier;
+    value: ESLintExpression | null;
+}
+interface ESLintStaticBlock extends HasLocation, HasParent, Omit<ESLintBlockStatement, 'type'> {
+    type: 'StaticBlock';
+    body: ESLintStatement[];
+}
+interface ESLintPrivateIdentifier extends HasLocation, HasParent {
+    type: 'PrivateIdentifier';
+    name: string;
+}
+type ESLintModuleDeclaration = ESLintImportDeclaration | ESLintExportNamedDeclaration | ESLintExportDefaultDeclaration | ESLintExportAllDeclaration;
+type ESLintModuleSpecifier = ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier | ESLintExportSpecifier;
+interface ESLintImportDeclaration extends HasLocation, HasParent {
+    type: 'ImportDeclaration';
+    specifiers: (ESLintImportSpecifier | ESLintImportDefaultSpecifier | ESLintImportNamespaceSpecifier)[];
+    source: ESLintLiteral;
+}
+interface ESLintImportSpecifier extends HasLocation, HasParent {
+    type: 'ImportSpecifier';
+    imported: ESLintIdentifier | ESLintStringLiteral;
+    local: ESLintIdentifier;
+}
+interface ESLintImportDefaultSpecifier extends HasLocation, HasParent {
+    type: 'ImportDefaultSpecifier';
+    local: ESLintIdentifier;
+}
+interface ESLintImportNamespaceSpecifier extends HasLocation, HasParent {
+    type: 'ImportNamespaceSpecifier';
+    local: ESLintIdentifier;
+}
+interface ESLintImportExpression extends HasLocation, HasParent {
+    type: 'ImportExpression';
+    source: ESLintExpression;
+}
+interface ESLintExportNamedDeclaration extends HasLocation, HasParent {
+    type: 'ExportNamedDeclaration';
+    declaration?: ESLintDeclaration | null;
+    specifiers: ESLintExportSpecifier[];
+    source?: ESLintLiteral | null;
+}
+interface ESLintExportSpecifier extends HasLocation, HasParent {
+    type: 'ExportSpecifier';
+    local: ESLintIdentifier | ESLintStringLiteral;
+    exported: ESLintIdentifier | ESLintStringLiteral;
+}
+interface ESLintExportDefaultDeclaration extends HasLocation, HasParent {
+    type: 'ExportDefaultDeclaration';
+    declaration: ESLintDeclaration | ESLintExpression;
+}
+interface ESLintExportAllDeclaration extends HasLocation, HasParent {
+    type: 'ExportAllDeclaration';
+    exported: ESLintIdentifier | ESLintStringLiteral | null;
+    source: ESLintLiteral;
+}
+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 | ESLintChainExpression;
+interface ESLintIdentifier extends HasLocation, HasParent {
+    type: 'Identifier';
+    name: string;
+}
+interface ESLintLiteralBase extends HasLocation, HasParent {
+    type: 'Literal';
+    value: string | boolean | null | number | RegExp | bigint;
+    raw: string;
+    regex?: {
+        pattern: string;
+        flags: string;
+    };
+    bigint?: string;
+}
+interface ESLintStringLiteral extends ESLintLiteralBase {
+    value: string;
+    regex?: undefined;
+    bigint?: undefined;
+}
+interface ESLintBooleanLiteral extends ESLintLiteralBase {
+    value: boolean;
+    regex?: undefined;
+    bigint?: undefined;
+}
+interface ESLintNullLiteral extends ESLintLiteralBase {
+    value: null;
+    regex?: undefined;
+    bigint?: undefined;
+}
+interface ESLintNumberLiteral extends ESLintLiteralBase {
+    value: number;
+    regex?: undefined;
+    bigint?: undefined;
+}
+interface ESLintRegExpLiteral extends ESLintLiteralBase {
+    value: null | RegExp;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    bigint?: undefined;
+}
+interface ESLintBigIntLiteral extends ESLintLiteralBase {
+    value: null | bigint;
+    regex?: undefined;
+    bigint: string;
+}
+type ESLintLiteral = ESLintStringLiteral | ESLintBooleanLiteral | ESLintNullLiteral | ESLintNumberLiteral | ESLintRegExpLiteral | ESLintBigIntLiteral;
+interface ESLintThisExpression extends HasLocation, HasParent {
+    type: 'ThisExpression';
+}
+interface ESLintArrayExpression extends HasLocation, HasParent {
+    type: 'ArrayExpression';
+    elements: (ESLintExpression | ESLintSpreadElement)[];
+}
+interface ESLintObjectExpression extends HasLocation, HasParent {
+    type: 'ObjectExpression';
+    properties: (ESLintProperty | ESLintSpreadElement | ESLintLegacySpreadProperty)[];
+}
+interface ESLintProperty extends HasLocation, HasParent {
+    type: 'Property';
+    kind: 'init' | 'get' | 'set';
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    key: ESLintExpression;
+    value: ESLintExpression | ESLintPattern;
+}
+interface ESLintFunctionExpression extends HasLocation, HasParent {
+    type: 'FunctionExpression';
+    async: boolean;
+    generator: boolean;
+    id: ESLintIdentifier | null;
+    params: ESLintPattern[];
+    body: ESLintBlockStatement;
+}
+interface ESLintArrowFunctionExpression extends HasLocation, HasParent {
+    type: 'ArrowFunctionExpression';
+    async: boolean;
+    generator: boolean;
+    id: ESLintIdentifier | null;
+    params: ESLintPattern[];
+    body: ESLintBlockStatement;
+}
+interface ESLintSequenceExpression extends HasLocation, HasParent {
+    type: 'SequenceExpression';
+    expressions: ESLintExpression[];
+}
+interface ESLintUnaryExpression extends HasLocation, HasParent {
+    type: 'UnaryExpression';
+    operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
+    prefix: boolean;
+    argument: ESLintExpression;
+}
+interface ESLintBinaryExpression extends HasLocation, HasParent {
+    type: 'BinaryExpression';
+    operator: '==' | '!=' | '===' | '!==' | '<' | '<=' | '>' | '>=' | '<<' | '>>' | '>>>' | '+' | '-' | '*' | '/' | '%' | '**' | '|' | '^' | '&' | 'in' | 'instanceof';
+    left: ESLintExpression | ESLintPrivateIdentifier;
+    right: ESLintExpression;
+}
+interface ESLintAssignmentExpression extends HasLocation, HasParent {
+    type: 'AssignmentExpression';
+    operator: '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '**=' | '<<=' | '>>=' | '>>>=' | '|=' | '^=' | '&=' | '||=' | '&&=' | '??=';
+    left: ESLintPattern;
+    right: ESLintExpression;
+}
+interface ESLintUpdateExpression extends HasLocation, HasParent {
+    type: 'UpdateExpression';
+    operator: '++' | '--';
+    argument: ESLintExpression;
+    prefix: boolean;
+}
+interface ESLintLogicalExpression extends HasLocation, HasParent {
+    type: 'LogicalExpression';
+    operator: '||' | '&&' | '??';
+    left: ESLintExpression;
+    right: ESLintExpression;
+}
+interface ESLintConditionalExpression extends HasLocation, HasParent {
+    type: 'ConditionalExpression';
+    test: ESLintExpression;
+    alternate: ESLintExpression;
+    consequent: ESLintExpression;
+}
+interface ESLintCallExpression extends HasLocation, HasParent {
+    type: 'CallExpression';
+    optional: boolean;
+    callee: ESLintExpression | ESLintSuper;
+    arguments: (ESLintExpression | ESLintSpreadElement)[];
+}
+interface ESLintSuper extends HasLocation, HasParent {
+    type: 'Super';
+}
+interface ESLintNewExpression extends HasLocation, HasParent {
+    type: 'NewExpression';
+    callee: ESLintExpression;
+    arguments: (ESLintExpression | ESLintSpreadElement)[];
+}
+interface ESLintMemberExpression extends HasLocation, HasParent {
+    type: 'MemberExpression';
+    optional: boolean;
+    computed: boolean;
+    object: ESLintExpression | ESLintSuper;
+    property: ESLintExpression | ESLintPrivateIdentifier;
+}
+interface ESLintYieldExpression extends HasLocation, HasParent {
+    type: 'YieldExpression';
+    delegate: boolean;
+    argument: ESLintExpression | null;
+}
+interface ESLintAwaitExpression extends HasLocation, HasParent {
+    type: 'AwaitExpression';
+    argument: ESLintExpression;
+}
+interface ESLintTemplateLiteral extends HasLocation, HasParent {
+    type: 'TemplateLiteral';
+    quasis: ESLintTemplateElement[];
+    expressions: ESLintExpression[];
+}
+interface ESLintTaggedTemplateExpression extends HasLocation, HasParent {
+    type: 'TaggedTemplateExpression';
+    tag: ESLintExpression;
+    quasi: ESLintTemplateLiteral;
+}
+interface ESLintTemplateElement extends HasLocation, HasParent {
+    type: 'TemplateElement';
+    tail: boolean;
+    value: {
+        cooked: string | null;
+        raw: string;
+    };
+}
+interface ESLintClassExpression extends HasLocation, HasParent {
+    type: 'ClassExpression';
+    id: ESLintIdentifier | null;
+    superClass: ESLintExpression | null;
+    body: ESLintClassBody;
+}
+interface ESLintMetaProperty extends HasLocation, HasParent {
+    type: 'MetaProperty';
+    meta: ESLintIdentifier;
+    property: ESLintIdentifier;
+}
+type ESLintPattern = ESLintIdentifier | ESLintObjectPattern | ESLintArrayPattern | ESLintRestElement | ESLintAssignmentPattern | ESLintMemberExpression | ESLintLegacyRestProperty;
+interface ESLintObjectPattern extends HasLocation, HasParent {
+    type: 'ObjectPattern';
+    properties: (ESLintAssignmentProperty | ESLintRestElement | ESLintLegacyRestProperty)[];
+}
+interface ESLintAssignmentProperty extends ESLintProperty {
+    value: ESLintPattern;
+    kind: 'init';
+    method: false;
+}
+interface ESLintArrayPattern extends HasLocation, HasParent {
+    type: 'ArrayPattern';
+    elements: ESLintPattern[];
+}
+interface ESLintRestElement extends HasLocation, HasParent {
+    type: 'RestElement';
+    argument: ESLintPattern;
+}
+interface ESLintSpreadElement extends HasLocation, HasParent {
+    type: 'SpreadElement';
+    argument: ESLintExpression;
+}
+interface ESLintAssignmentPattern extends HasLocation, HasParent {
+    type: 'AssignmentPattern';
+    left: ESLintPattern;
+    right: ESLintExpression;
+}
+type ESLintChainElement = ESLintCallExpression | ESLintMemberExpression;
+interface ESLintChainExpression extends HasLocation, HasParent {
+    type: 'ChainExpression';
+    expression: ESLintChainElement;
+}
+/**
+ * Legacy for babel-eslint and espree.
+ */
+interface ESLintLegacyRestProperty extends HasLocation, HasParent {
+    type: 'RestProperty' | 'ExperimentalRestProperty';
+    argument: ESLintPattern;
+}
+/**
+ * Legacy for babel-eslint and espree.
+ */
+interface ESLintLegacySpreadProperty extends HasLocation, HasParent {
+    type: 'SpreadProperty' | 'ExperimentalSpreadProperty';
+    argument: ESLintExpression;
+}
+/**
+ * Constants of namespaces.
+ * @see https://infra.spec.whatwg.org/#namespaces
+ */
+declare const NS: Readonly<{
+    HTML: "http://www.w3.org/1999/xhtml";
+    MathML: "http://www.w3.org/1998/Math/MathML";
+    SVG: "http://www.w3.org/2000/svg";
+    XLink: "http://www.w3.org/1999/xlink";
+    XML: "http://www.w3.org/XML/1998/namespace";
+    XMLNS: "http://www.w3.org/2000/xmlns/";
+}>;
+/**
+ * Type of namespaces.
+ */
+type Namespace = typeof NS.HTML | typeof NS.MathML | typeof NS.SVG | typeof NS.XLink | typeof NS.XML | typeof NS.XMLNS;
+/**
+ * Type of variable definitions.
+ */
+interface Variable {
+    id: ESLintIdentifier;
+    kind: 'v-for' | 'scope';
+    references: Reference[];
+}
+/**
+ * Type of variable references.
+ */
+interface Reference {
+    id: ESLintIdentifier;
+    mode: 'rw' | 'r' | 'w';
+    variable: Variable | null;
+    isValueReference?: boolean;
+    isTypeReference?: boolean;
+}
+/**
+ * The node of `v-for` directives.
+ */
+interface VForExpression extends HasLocation, HasParent {
+    type: 'VForExpression';
+    parent: VExpressionContainer;
+    left: ESLintPattern[];
+    right: ESLintExpression;
+}
+/**
+ * The node of `v-on` directives.
+ */
+interface VOnExpression extends HasLocation, HasParent {
+    type: 'VOnExpression';
+    parent: VExpressionContainer;
+    body: ESLintStatement[];
+}
+/**
+ * The node of `slot-scope` directives.
+ */
+interface VSlotScopeExpression extends HasLocation, HasParent {
+    type: 'VSlotScopeExpression';
+    parent: VExpressionContainer;
+    params: ESLintPattern[];
+}
+/**
+ * The node of a filter sequence which is separated by `|`.
+ */
+interface VFilterSequenceExpression extends HasLocation, HasParent {
+    type: 'VFilterSequenceExpression';
+    parent: VExpressionContainer;
+    expression: ESLintExpression;
+    filters: VFilter[];
+}
+/**
+ * The node of a filter sequence which is separated by `|`.
+ */
+interface VFilter extends HasLocation, HasParent {
+    type: 'VFilter';
+    parent: VFilterSequenceExpression;
+    callee: ESLintIdentifier;
+    arguments: (ESLintExpression | ESLintSpreadElement)[];
+}
+/**
+ * The union type of any nodes.
+ */
+type VNode = VAttribute | VDirective | VDirectiveKey | VTemplateRoot | VElement | VEndTag | VExpressionContainer | VIdentifier | VLiteral | VStartTag | VText;
+/**
+ * Text nodes.
+ */
+interface VText extends HasLocation, HasParent {
+    type: 'VText';
+    parent: VTemplateRoot | VElement;
+    value: string;
+}
+/**
+ * The node of JavaScript expression in text.
+ * e.g. `{{ name }}`
+ */
+interface VExpressionContainer extends HasLocation, HasParent {
+    type: 'VExpressionContainer';
+    parent: VTemplateRoot | VElement | VDirective | VDirectiveKey;
+    expression: ESLintExpression | VFilterSequenceExpression | VForExpression | VOnExpression | VSlotScopeExpression | null;
+    references: Reference[];
+}
+/**
+ * Attribute name nodes.
+ */
+interface VIdentifier extends HasLocation, HasParent {
+    type: 'VIdentifier';
+    parent: VAttribute | VDirectiveKey;
+    name: string;
+    rawName: string;
+}
+/**
+ * Attribute name nodes.
+ */
+interface VDirectiveKey extends HasLocation, HasParent {
+    type: 'VDirectiveKey';
+    parent: VDirective;
+    name: VIdentifier;
+    argument: VExpressionContainer | VIdentifier | null;
+    modifiers: VIdentifier[];
+}
+/**
+ * Attribute value nodes.
+ */
+interface VLiteral extends HasLocation, HasParent {
+    type: 'VLiteral';
+    parent: VAttribute;
+    value: string;
+}
+/**
+ * Static attribute nodes.
+ */
+interface VAttribute extends HasLocation, HasParent {
+    type: 'VAttribute';
+    parent: VStartTag;
+    directive: false;
+    key: VIdentifier;
+    value: VLiteral | null;
+}
+/**
+ * Directive nodes.
+ */
+interface VDirective extends HasLocation, HasParent {
+    type: 'VAttribute';
+    parent: VStartTag;
+    directive: true;
+    key: VDirectiveKey;
+    value: VExpressionContainer | null;
+}
+/**
+ * Start tag nodes.
+ */
+interface VStartTag extends HasLocation, HasParent {
+    type: 'VStartTag';
+    parent: VElement;
+    selfClosing: boolean;
+    attributes: (VAttribute | VDirective)[];
+}
+/**
+ * End tag nodes.
+ */
+interface VEndTag extends HasLocation, HasParent {
+    type: 'VEndTag';
+    parent: VElement;
+}
+/**
+ * The property which has concrete information.
+ */
+interface HasConcreteInfo {
+    tokens: Token[];
+    comments: Token[];
+    errors: ParseError[];
+}
+/**
+ * Element nodes.
+ */
+interface VElement extends HasLocation, HasParent {
+    type: 'VElement';
+    parent: VTemplateRoot | VElement;
+    namespace: Namespace;
+    name: string;
+    rawName: string;
+    startTag: VStartTag;
+    children: (VElement | VText | VExpressionContainer)[];
+    endTag: VEndTag | null;
+    variables: Variable[];
+}
+/**
+ * Root nodes.
+ */
+interface VTemplateRoot extends HasLocation {
+    type: 'VTemplateRoot';
+    parent: TSESTree.Node;
+    children: (VElement | VText | VExpressionContainer)[];
+}
+
+/**
+ * The type of basic ESLint custom parser.
+ * e.g. espree
+ */
+interface BasicParserObject<R = ESLintProgram> {
+    parse: (code: string, options: any) => R;
+    parseForESLint: undefined;
+}
+/**
+ * The type of ESLint custom parser enhanced for ESLint.
+ * e.g. @babel/eslint-parser, @typescript-eslint/parser
+ */
+interface EnhancedParserObject<R = ESLintExtendedProgram> {
+    parseForESLint: (code: string, options: any) => R;
+    parse: undefined;
+}
+/**
+ * The type of ESLint (custom) parsers.
+ */
+type ParserObject<R1 = ESLintExtendedProgram, R2 = ESLintProgram> = EnhancedParserObject<R1> | BasicParserObject<R2>;
+
+type VineESLintAST = TSESTree.Program;
+type ParseForESLintResult = ReturnType<typeof parseForESLint$1>;
+type VineESLintParserOptions = ParserOptions & {
+    parser?: boolean | string | ParserObject | Record<string, string | ParserObject | undefined>;
+    ecmaFeatures?: ParserOptions['ecmaFeatures'] & {
+        [key: string]: any;
+    };
+};
+
+declare function parse(code: string, parserOptions: VineESLintParserOptions): VineESLintAST;
+declare function parseForESLint(code: string, parserOptions: VineESLintParserOptions): ParseForESLintResult;
+
+export { parse, parseForESLint };