* Set offset to the given tokens.

* Process the given node list. * The first node is offsetted from the given left token. * Rest nodes are adjusted to the first node. * * @

@deprecated removed in ESLint v9

* Wrap a core rule or ESLint Stylistic rule to apply it to Vue.js template. * @param {RuleNames|string} ruleNames The names of the rule implementatio

* Get the first and last tokens of the given node. * If the node is parenthesized, this gets the outermost parentheses. * The `borderOffset` val

* Gets the property name of a given node. * @param {Property|AssignmentProperty|MethodDefinition|MemberExpression} node - The node to get. * @return

* Get TypeScript instance

* Wrap a given core rule to apply it to Vue.js template. * @param {string} coreRuleName The name of the core rule implementation to wrap. * @param {

* Retrieve `TSAsExpression#expression` value if the given node a `TSAsExpression` node. Otherwise, pass through it. * @template T Node type * @param

* Report

* Extract the property references from Expression.

* We need to handle cases like "const props = defineProps(...)" * Define macros must be used only on top, so we can look for "Program" type * inside

* Gets the scope for the current node * @param {RuleContext} context The rule context * @param {ESNode} currentNode The node to get the scope of *

* Gets the string of a given node. * @param {Literal|TemplateLiteral} node - The node to get. * @param {boolean} [stringOnly] * @return {string|nul

* @param {ComponentEmit} emit

* Register the given visitor to parser services. * If the parser service of `vue-eslint-parser` was not found, * this generates a warning. * * @pa

* Process the given node as body. * The body node maybe a block statement or an expression node.

* Get TypeScript parser services. * @param {RuleContext} context The ESLint rule context object. * @returns {Services|null}

* Check if a given type is an object type or not. * @param {Type} tsType The type to check. * @returns {tsType is ObjectType}

* Check whether the given attribute is `v-bind` directive. * @param {VAttribute | VDirective | undefined | null} node * @returns { node is VBindDire

* @param {any} initialOption * @param {string} optionKey * @private *

* Removes errors that occur inside a string node * @param {ASTNode | Token} node to check for matching errors. * @returns {void} * @pri

* @param {RuleContext} context * @param {Expression} node * @returns {Set<Expression>}

* Get attribute value from given element.

* Get the core rule implementation from the rule name * @param {string} name * @returns {RuleModule | null}

* Gets the element of `<script setup>` * @param {RuleContext} context The ESLint rule context object. * @returns {VElement | null} the element of `<

* Get the Vue component definition type from given node * Vue.component('xxx', {}) || component('xxx', {}) * @param {RuleContext} context The rule c

* Checks whether the given string has symbols.

* Check if a given type is an any type or not. * @param {Type} tsType The type to check.

* Check if a given type is a never type or not. * @param {Type} tsType The type to check.

* Check if a given type is an null type or not. * @param {Type} tsType The type to check.

* Check if a given type is an unknown type or not. * @param {Type} tsType The type to check.

* @template {object} T * @param {T} target * @param {Partial<T>[]} propsArray * @returns {T}

* @param {(Property | SpreadElement)[]} properties * @param {any} option * @param {any} nextOption *

* @param {ESNode} node * @param {BlockStatement | Expression} targetBody * @param {keyof expressionTypes} type * @param {ComponentCompu

* Checks whether the given node can convert to the `v-slot`. * @param {VStartTag} startTag node of `<element v-slot ... >` * @returns {boole

* @template T * @param {T} visitor * @param {...(TemplateListener | RuleListener | NodeListener)} visitors * @returns {T}

* Extract the property references from name.

* Finds the property with the given name from the given ObjectExpression node. * @param {ObjectExpression} node * @param {string} name * @param { (

* @param {RuleContext} context The ESLint rule context object. * @param {TSESTreeTypeNode} node * @returns {(TSESTreeTypeNode|TSESTreeTSInterfaceBod

* Gets the parent node of the given node. This method returns a value ignoring `X as F`. * @param {Expression} node * @returns {ASTNode}

* Gets the property of the Object node passed in that has the name specified. * * @param {string} propertyName Name of the property to return. * @p

* @param {MemberExpression|AssignmentProperty} node * @returns {string}

* Get token information for the given VExpressionContainer node. * @param {VExpressionContainer} node

* Check whether the given start tag has specific directive. * @param {VElement} node The start tag node to check. * @param {string} name The directi

* Checks whether given defineProps call node has withDefaults. * @param {CallExpression} node The node of defineProps * @returns {node is CallExpres

* Ignore all tokens of the given node.

* Checks whether the given node is Property. * @param {Property | SpreadElement | AssignmentProperty} node * @returns {node is Property}

* @param {ASTNode} node * @returns {node is Literal | TemplateLiteral}

* @param {TSESTreeTypeNode|TSESTreeTSInterfaceBody} node * @returns {node is TSESTreeTSInterfaceBody}

* @param {TSESTreeTypeNode} node * @returns {node is TSESTreeTSTypeLiteral}

* Check whether the given attribute is plain attribute, `v-bind` directive or `v-model` directive. * @param {VAttribute | VDirective | undefined | nu

* Check whether the given attribute is `v-bind="..."` directive. * @param {VAttribute | VDirective | undefined | null} node * @returns { node is VBi

* @param {ComponentStack} component