@elizaos/config 1.7.1-alpha.9 → 1.7.1

package/dist/index.js

@@ -182668,6 +182668,7 @@ var require_node_utils = __commonJS((exports) => {
   exports.isValidAssignmentTarget = isValidAssignmentTarget;
   exports.getNamespaceModifiers = getNamespaceModifiers;
   exports.declarationNameToString = declarationNameToString;
+  exports.isEntityNameExpression = isEntityNameExpression;
   var ts = __importStar(require_typescript());
   var getModifiers_1 = require_getModifiers();
   var xhtml_entities_1 = require_xhtml_entities();
@@ -183099,10 +183100,16 @@ var require_node_utils = __commonJS((exports) => {
     }
     return modifiers;
   }
-  function declarationNameToString(name, ast) {
-    const text = ast.text.slice(name.pos, name.end).trimStart();
+  function declarationNameToString(node) {
+    const text = node.getSourceFile().text.slice(node.pos, node.end).trimStart();
     return text || "(Missing)";
   }
+  function isPropertyAccessEntityNameExpression(node) {
+    return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && isEntityNameExpression(node.expression);
+  }
+  function isEntityNameExpression(node) {
+    return node.kind === SyntaxKind.Identifier || isPropertyAccessEntityNameExpression(node);
+  }
 });
 
 // ../../node_modules/@typescript-eslint/typescript-estree/dist/check-modifiers.js
@@ -183299,6 +183306,397 @@ var require_check_modifiers = __commonJS((exports) => {
   }
 });
 
+// ../../node_modules/@typescript-eslint/typescript-estree/dist/check-syntax-errors.js
+var require_check_syntax_errors = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k = ownKeys(mod), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod, k[i]);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.checkSyntaxError = checkSyntaxError;
+  var ts = __importStar(require_typescript());
+  var check_modifiers_1 = require_check_modifiers();
+  var node_utils_1 = require_node_utils();
+  var SyntaxKind = ts.SyntaxKind;
+  function checkSyntaxError(tsNode, parent, allowPattern) {
+    (0, check_modifiers_1.checkModifiers)(tsNode);
+    const node = tsNode;
+    switch (node.kind) {
+      case SyntaxKind.SwitchStatement:
+        if (node.caseBlock.clauses.filter((switchCase) => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
+          throw (0, node_utils_1.createError)(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
+        }
+        break;
+      case SyntaxKind.ThrowStatement:
+        if (node.expression.end === node.expression.pos) {
+          throw (0, node_utils_1.createError)(node, "A throw statement must throw an expression.");
+        }
+        break;
+      case SyntaxKind.CatchClause:
+        if (node.variableDeclaration?.initializer) {
+          throw (0, node_utils_1.createError)(node.variableDeclaration.initializer, "Catch clause variable cannot have an initializer.");
+        }
+        break;
+      case SyntaxKind.FunctionDeclaration: {
+        const isDeclare = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
+        const isAsync = (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node);
+        const isGenerator = !!node.asteriskToken;
+        if (isDeclare) {
+          if (node.body) {
+            throw (0, node_utils_1.createError)(node, "An implementation cannot be declared in ambient contexts.");
+          } else if (isAsync) {
+            throw (0, node_utils_1.createError)(node, "'async' modifier cannot be used in an ambient context.");
+          } else if (isGenerator) {
+            throw (0, node_utils_1.createError)(node, "Generators are not allowed in an ambient context.");
+          }
+        } else if (!node.body && isGenerator) {
+          throw (0, node_utils_1.createError)(node, "A function signature cannot be declared as a generator.");
+        }
+        break;
+      }
+      case SyntaxKind.VariableDeclaration: {
+        const hasExclamationToken = !!node.exclamationToken;
+        if (hasExclamationToken) {
+          if (node.initializer) {
+            throw (0, node_utils_1.createError)(node, "Declarations with initializers cannot also have definite assignment assertions.");
+          } else if (node.name.kind !== SyntaxKind.Identifier || !node.type) {
+            throw (0, node_utils_1.createError)(node, "Declarations with definite assignment assertions must also have type annotations.");
+          }
+        }
+        if (node.parent.kind === SyntaxKind.VariableDeclarationList) {
+          const variableDeclarationList = node.parent;
+          const kind = (0, node_utils_1.getDeclarationKind)(variableDeclarationList);
+          if (kind === "using" || kind === "await using") {
+            if (variableDeclarationList.parent.kind === SyntaxKind.ForInStatement) {
+              throw (0, node_utils_1.createError)(variableDeclarationList, `The left-hand side of a 'for...in' statement cannot be a '${kind}' declaration.`);
+            }
+            if (variableDeclarationList.parent.kind === SyntaxKind.ForStatement || variableDeclarationList.parent.kind === SyntaxKind.VariableStatement) {
+              if (!node.initializer) {
+                throw (0, node_utils_1.createError)(node, `'${kind}' declarations must be initialized.`);
+              }
+              if (node.name.kind !== SyntaxKind.Identifier) {
+                throw (0, node_utils_1.createError)(node.name, `'${kind}' declarations may not have binding patterns.`);
+              }
+            }
+          }
+          if (variableDeclarationList.parent.kind === SyntaxKind.VariableStatement) {
+            const variableStatement = variableDeclarationList.parent;
+            const hasDeclareKeyword = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, variableStatement);
+            if ((hasDeclareKeyword || ["await using", "const", "using"].includes(kind)) && hasExclamationToken) {
+              throw (0, node_utils_1.createError)(node, `A definite assignment assertion '!' is not permitted in this context.`);
+            }
+            if (hasDeclareKeyword && node.initializer && (["let", "var"].includes(kind) || node.type)) {
+              throw (0, node_utils_1.createError)(node, `Initializers are not permitted in ambient contexts.`);
+            }
+          }
+        }
+        break;
+      }
+      case SyntaxKind.VariableStatement: {
+        const declarations = node.declarationList.declarations;
+        if (!declarations.length) {
+          throw (0, node_utils_1.createError)(node, "A variable declaration list must have at least one variable declarator.");
+        }
+        break;
+      }
+      case SyntaxKind.PropertyAssignment: {
+        const { exclamationToken, questionToken } = node;
+        if (questionToken) {
+          throw (0, node_utils_1.createError)(questionToken, "A property assignment cannot have a question token.");
+        }
+        if (exclamationToken) {
+          throw (0, node_utils_1.createError)(exclamationToken, "A property assignment cannot have an exclamation token.");
+        }
+        break;
+      }
+      case SyntaxKind.ShorthandPropertyAssignment: {
+        const { exclamationToken, modifiers, questionToken } = node;
+        if (modifiers) {
+          throw (0, node_utils_1.createError)(modifiers[0], "A shorthand property assignment cannot have modifiers.");
+        }
+        if (questionToken) {
+          throw (0, node_utils_1.createError)(questionToken, "A shorthand property assignment cannot have a question token.");
+        }
+        if (exclamationToken) {
+          throw (0, node_utils_1.createError)(exclamationToken, "A shorthand property assignment cannot have an exclamation token.");
+        }
+        break;
+      }
+      case SyntaxKind.PropertyDeclaration: {
+        const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
+        if (isAbstract && node.initializer) {
+          throw (0, node_utils_1.createError)(node.initializer, `Abstract property cannot have an initializer.`);
+        }
+        if (node.name.kind === SyntaxKind.StringLiteral && node.name.text === "constructor") {
+          throw (0, node_utils_1.createError)(node.name, "Classes may not have a field named 'constructor'.");
+        }
+        break;
+      }
+      case SyntaxKind.TaggedTemplateExpression:
+        if (node.tag.flags & ts.NodeFlags.OptionalChain) {
+          throw (0, node_utils_1.createError)(node, "Tagged template expressions are not permitted in an optional chain.");
+        }
+        break;
+      case SyntaxKind.BinaryExpression:
+        if (node.operatorToken.kind !== SyntaxKind.InKeyword && node.left.kind === SyntaxKind.PrivateIdentifier) {
+          throw (0, node_utils_1.createError)(node.left, "Private identifiers cannot appear on the right-hand-side of an 'in' expression.");
+        } else if (node.right.kind === SyntaxKind.PrivateIdentifier) {
+          throw (0, node_utils_1.createError)(node.right, "Private identifiers are only allowed on the left-hand-side of an 'in' expression.");
+        }
+        break;
+      case SyntaxKind.MappedType:
+        if (node.members && node.members.length > 0) {
+          throw (0, node_utils_1.createError)(node.members[0], "A mapped type may not declare properties or methods.");
+        }
+        break;
+      case SyntaxKind.PropertySignature: {
+        const { initializer } = node;
+        if (initializer) {
+          throw (0, node_utils_1.createError)(initializer, "A property signature cannot have an initializer.");
+        }
+        break;
+      }
+      case SyntaxKind.FunctionType: {
+        const { modifiers } = node;
+        if (modifiers) {
+          throw (0, node_utils_1.createError)(modifiers[0], "A function type cannot have modifiers.");
+        }
+        break;
+      }
+      case SyntaxKind.EnumMember: {
+        const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
+        if (computed) {
+          throw (0, node_utils_1.createError)(node.name, "Computed property names are not allowed in enums.");
+        }
+        if (node.name.kind === SyntaxKind.NumericLiteral || node.name.kind === SyntaxKind.BigIntLiteral) {
+          throw (0, node_utils_1.createError)(node.name, "An enum member cannot have a numeric name.");
+        }
+        break;
+      }
+      case SyntaxKind.ExternalModuleReference:
+        if (node.expression.kind !== SyntaxKind.StringLiteral) {
+          throw (0, node_utils_1.createError)(node.expression, "String literal expected.");
+        }
+        break;
+      case SyntaxKind.PrefixUnaryExpression:
+      case SyntaxKind.PostfixUnaryExpression: {
+        const operator = (0, node_utils_1.getTextForTokenKind)(node.operator);
+        if ((operator === "++" || operator === "--") && !(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
+          throw (0, node_utils_1.createError)(node.operand, "Invalid left-hand side expression in unary operation");
+        }
+        break;
+      }
+      case SyntaxKind.ImportDeclaration: {
+        const { importClause } = node;
+        if (importClause?.isTypeOnly && importClause.name && importClause.namedBindings) {
+          throw (0, node_utils_1.createError)(importClause, "A type-only import can specify a default import or named bindings, but not both.");
+        }
+        assertModuleSpecifier(node, false);
+        break;
+      }
+      case SyntaxKind.ExportDeclaration:
+        assertModuleSpecifier(node, node.exportClause?.kind === SyntaxKind.NamedExports);
+        break;
+      case SyntaxKind.ExportSpecifier: {
+        const local = node.propertyName ?? node.name;
+        if (local.kind === SyntaxKind.StringLiteral && parent.kind === SyntaxKind.ExportDeclaration && parent.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
+          throw (0, node_utils_1.createError)(local, "A string literal cannot be used as a local exported binding without `from`.");
+        }
+        break;
+      }
+      case SyntaxKind.CallExpression:
+        if (node.expression.kind === SyntaxKind.ImportKeyword && node.arguments.length !== 1 && node.arguments.length !== 2) {
+          throw (0, node_utils_1.createError)(node.arguments.length > 1 ? node.arguments[2] : node, "Dynamic import requires exactly one or two arguments.");
+        }
+        break;
+      case SyntaxKind.ClassDeclaration:
+        if (!node.name && (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) || !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
+          throw (0, node_utils_1.createError)(node, "A class declaration without the 'default' modifier must have a name.");
+        }
+      case SyntaxKind.ClassExpression: {
+        const heritageClauses = node.heritageClauses ?? [];
+        let seenExtendsClause = false;
+        let seenImplementsClause = false;
+        for (const heritageClause of heritageClauses) {
+          const { token, types } = heritageClause;
+          if (types.length === 0) {
+            throw (0, node_utils_1.createError)(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+          }
+          if (token === SyntaxKind.ExtendsKeyword) {
+            if (seenExtendsClause) {
+              throw (0, node_utils_1.createError)(heritageClause, "'extends' clause already seen.");
+            }
+            if (seenImplementsClause) {
+              throw (0, node_utils_1.createError)(heritageClause, "'extends' clause must precede 'implements' clause.");
+            }
+            if (types.length > 1) {
+              throw (0, node_utils_1.createError)(types[1], "Classes can only extend a single class.");
+            }
+            seenExtendsClause = true;
+          } else {
+            if (seenImplementsClause) {
+              throw (0, node_utils_1.createError)(heritageClause, "'implements' clause already seen.");
+            }
+            for (const heritageType of heritageClause.types) {
+              if (!(0, node_utils_1.isEntityNameExpression)(heritageType.expression) || ts.isOptionalChain(heritageType.expression)) {
+                throw (0, node_utils_1.createError)(heritageType, "A class can only implement an identifier/qualified-name with optional type arguments.");
+              }
+            }
+            seenImplementsClause = true;
+          }
+        }
+        break;
+      }
+      case SyntaxKind.InterfaceDeclaration: {
+        const interfaceHeritageClauses = node.heritageClauses ?? [];
+        let seenExtendsClause = false;
+        for (const heritageClause of interfaceHeritageClauses) {
+          const { token, types } = heritageClause;
+          if (token === SyntaxKind.ImplementsKeyword) {
+            throw (0, node_utils_1.createError)(heritageClause, "Interface declaration cannot have 'implements' clause.");
+          }
+          if (token !== SyntaxKind.ExtendsKeyword) {
+            throw (0, node_utils_1.createError)(heritageClause, "Unexpected token.");
+          }
+          if (types.length === 0) {
+            throw (0, node_utils_1.createError)(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+          }
+          if (seenExtendsClause) {
+            throw (0, node_utils_1.createError)(heritageClause, "'extends' clause already seen.");
+          }
+          seenExtendsClause = true;
+          for (const heritageType of heritageClause.types) {
+            if (!(0, node_utils_1.isEntityNameExpression)(heritageType.expression) || ts.isOptionalChain(heritageType.expression)) {
+              throw (0, node_utils_1.createError)(heritageType, "Interface declaration can only extend an identifier/qualified name with optional type arguments.");
+            }
+          }
+        }
+        break;
+      }
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.SetAccessor:
+        if (node.parent.kind === SyntaxKind.InterfaceDeclaration || node.parent.kind === SyntaxKind.TypeLiteral) {
+          return;
+        }
+      case SyntaxKind.MethodDeclaration: {
+        const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
+        if (isAbstract && node.body) {
+          throw (0, node_utils_1.createError)(node.name, node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor ? "An abstract accessor cannot have an implementation." : `Method '${(0, node_utils_1.declarationNameToString)(node.name)}' cannot have an implementation because it is marked abstract.`);
+        }
+        break;
+      }
+      case SyntaxKind.ObjectLiteralExpression: {
+        if (!allowPattern) {
+          for (const property of node.properties) {
+            if ((property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor || property.kind === SyntaxKind.MethodDeclaration) && !property.body) {
+              throw (0, node_utils_1.createError)(property.end - 1, "'{' expected.", node.getSourceFile());
+            }
+          }
+        }
+        break;
+      }
+      case SyntaxKind.ImportEqualsDeclaration:
+        if (node.isTypeOnly && node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
+          throw (0, node_utils_1.createError)(node, "An import alias cannot use 'import type'");
+        }
+        break;
+      case SyntaxKind.ModuleDeclaration: {
+        if (node.flags & ts.NodeFlags.GlobalAugmentation) {
+          const { body } = node;
+          if (body == null || body.kind === SyntaxKind.ModuleDeclaration) {
+            throw (0, node_utils_1.createError)(node.body ?? node, "Expected a valid module body");
+          }
+          const { name } = node;
+          if (name.kind !== ts.SyntaxKind.Identifier) {
+            throw (0, node_utils_1.createError)(name, "global module augmentation must have an Identifier id");
+          }
+          return;
+        }
+        if (ts.isStringLiteral(node.name)) {
+          return;
+        }
+        if (node.body == null) {
+          throw (0, node_utils_1.createError)(node, "Expected a module body");
+        }
+        if (node.name.kind !== ts.SyntaxKind.Identifier) {
+          throw (0, node_utils_1.createError)(node.name, "`namespace`s must have an Identifier id");
+        }
+        break;
+      }
+      case SyntaxKind.ForInStatement:
+      case SyntaxKind.ForOfStatement: {
+        checkForStatementDeclaration(node);
+        break;
+      }
+    }
+  }
+  function checkForStatementDeclaration(node) {
+    const { initializer, kind } = node;
+    const loop = kind === SyntaxKind.ForInStatement ? "for...in" : "for...of";
+    if (ts.isVariableDeclarationList(initializer)) {
+      if (initializer.declarations.length !== 1) {
+        throw (0, node_utils_1.createError)(initializer, `Only a single variable declaration is allowed in a '${loop}' statement.`);
+      }
+      const declaration = initializer.declarations[0];
+      if (declaration.initializer) {
+        throw (0, node_utils_1.createError)(declaration, `The variable declaration of a '${loop}' statement cannot have an initializer.`);
+      } else if (declaration.type) {
+        throw (0, node_utils_1.createError)(declaration, `The variable declaration of a '${loop}' statement cannot have a type annotation.`);
+      }
+    } else if (!(0, node_utils_1.isValidAssignmentTarget)(initializer) && initializer.kind !== SyntaxKind.ObjectLiteralExpression && initializer.kind !== SyntaxKind.ArrayLiteralExpression) {
+      throw (0, node_utils_1.createError)(initializer, `The left-hand side of a '${loop}' statement must be a variable or a property access.`);
+    }
+  }
+  function assertModuleSpecifier(node, allowNull) {
+    if (!allowNull && node.moduleSpecifier == null) {
+      throw (0, node_utils_1.createError)(node, "Module specifier must be a string literal.");
+    }
+    if (node.moduleSpecifier && node.moduleSpecifier.kind !== SyntaxKind.StringLiteral) {
+      throw (0, node_utils_1.createError)(node.moduleSpecifier, "Module specifier must be a string literal.");
+    }
+  }
+});
+
 // ../../node_modules/@typescript-eslint/typescript-estree/dist/convert.js
 var require_convert = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
@@ -183349,7 +183747,7 @@ var require_convert = __commonJS((exports) => {
   exports.Converter = undefined;
   exports.convertError = convertError;
   var ts = __importStar(require_typescript());
-  var check_modifiers_1 = require_check_modifiers();
+  var check_syntax_errors_1 = require_check_syntax_errors();
   var getModifiers_1 = require_getModifiers();
   var node_utils_1 = require_node_utils();
   var ts_estree_1 = require_ts_estree2();
@@ -183357,12 +183755,6 @@ var require_convert = __commonJS((exports) => {
   function convertError(error) {
     return (0, node_utils_1.createError)(error.start, "message" in error && error.message || error.messageText, error.file);
   }
-  function isPropertyAccessEntityNameExpression(node) {
-    return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && isEntityNameExpression(node.expression);
-  }
-  function isEntityNameExpression(node) {
-    return node.kind === SyntaxKind.Identifier || isPropertyAccessEntityNameExpression(node);
-  }
 
   class Converter {
     allowPattern = false;
@@ -183374,30 +183766,11 @@ var require_convert = __commonJS((exports) => {
       this.ast = ast;
       this.options = { ...options };
     }
-    #checkForStatementDeclaration(initializer, kind) {
-      const loop = kind === ts.SyntaxKind.ForInStatement ? "for...in" : "for...of";
-      if (ts.isVariableDeclarationList(initializer)) {
-        if (initializer.declarations.length !== 1) {
-          this.#throwError(initializer, `Only a single variable declaration is allowed in a '${loop}' statement.`);
-        }
-        const declaration = initializer.declarations[0];
-        if (declaration.initializer) {
-          this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have an initializer.`);
-        } else if (declaration.type) {
-          this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have a type annotation.`);
-        }
-        if (kind === ts.SyntaxKind.ForInStatement && initializer.flags & ts.NodeFlags.Using) {
-          this.#throwError(initializer, "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.");
-        }
-      } else if (!(0, node_utils_1.isValidAssignmentTarget)(initializer) && initializer.kind !== ts.SyntaxKind.ObjectLiteralExpression && initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression) {
-        this.#throwError(initializer, `The left-hand side of a '${loop}' statement must be a variable or a property access.`);
-      }
-    }
-    #checkModifiers(node) {
+    #checkSyntaxError(node, parent) {
       if (this.options.allowInvalidAST) {
         return;
       }
-      (0, check_modifiers_1.checkModifiers)(node);
+      (0, check_syntax_errors_1.checkSyntaxError)(node, parent, this.allowPattern);
     }
     #throwError(node, message) {
       if (this.options.allowInvalidAST) {
@@ -183411,7 +183784,7 @@ var require_convert = __commonJS((exports) => {
         configurable: true,
         get: this.options.suppressDeprecatedPropertyWarnings ? () => node[valueKey] : () => {
           if (!warned) {
-            process.emitWarning(`The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, "DeprecationWarning");
+            process.emitWarning(`The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://tseslint.com/key-property-deprecated.`, "DeprecationWarning");
             warned = true;
           }
           return node[valueKey];
@@ -183436,7 +183809,7 @@ var require_convert = __commonJS((exports) => {
             if (preferredKey) {
               message += ` Use ${preferredKey} instead.`;
             }
-            message += " See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.";
+            message += " See https://tseslint.com/key-property-deprecated.";
             process.emitWarning(message, "DeprecationWarning");
             warned = true;
           }
@@ -183452,14 +183825,6 @@ var require_convert = __commonJS((exports) => {
       });
       return node;
     }
-    assertModuleSpecifier(node, allowNull) {
-      if (!allowNull && node.moduleSpecifier == null) {
-        this.#throwError(node, "Module specifier must be a string literal.");
-      }
-      if (node.moduleSpecifier && node.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-        this.#throwError(node.moduleSpecifier, "Module specifier must be a string literal.");
-      }
-    }
     convertBindingNameWithTypeAnnotation(name, tsType, parent) {
       const id = this.convertPattern(name);
       if (tsType) {
@@ -183533,7 +183898,11 @@ var require_convert = __commonJS((exports) => {
         typeAnnotation: this.convertChild(child)
       };
     }
-    convertTypeArgumentsToTypeParameterInstantiation(typeArguments, node) {
+    convertTypeArguments(node) {
+      const { typeArguments } = node;
+      if (!typeArguments) {
+        return;
+      }
       const greaterThanToken = (0, node_utils_1.findNextToken)(typeArguments, this.ast, this.ast);
       const range = [typeArguments.pos - 1, greaterThanToken.end];
       if (typeArguments.length === 0) {
@@ -183545,7 +183914,11 @@ var require_convert = __commonJS((exports) => {
         params: this.convertChildren(typeArguments)
       });
     }
-    convertTSTypeParametersToTypeParametersDeclaration(typeParameters) {
+    convertTypeParameters(node) {
+      const { typeParameters } = node;
+      if (!typeParameters) {
+        return;
+      }
       const greaterThanToken = (0, node_utils_1.findNextToken)(typeParameters, this.ast, this.ast);
       const range = [
         typeParameters.pos - 1,
@@ -183575,12 +183948,13 @@ var require_convert = __commonJS((exports) => {
       if (!node) {
         return null;
       }
-      this.#checkModifiers(node);
       const pattern = this.allowPattern;
       if (allowPattern != null) {
         this.allowPattern = allowPattern;
       }
-      const result = this.convertNode(node, parent ?? node.parent);
+      const parentNode = parent ?? node.parent;
+      this.#checkSyntaxError(node, parentNode);
+      const result = this.convertNode(node, parentNode);
       this.registerTSNodeInNodeMap(node, result);
       this.allowPattern = pattern;
       return result;
@@ -183678,7 +184052,7 @@ var require_convert = __commonJS((exports) => {
         readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node),
         returnType: node.type && this.convertTypeAnnotation(node.type, node),
         static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node),
-        typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+        typeParameters: this.convertTypeParameters(node)
       });
     }
     fixParentLocation(result, childRange) {
@@ -183764,9 +184138,6 @@ var require_convert = __commonJS((exports) => {
             test: this.convertChild(node.expression)
           });
         case SyntaxKind.SwitchStatement:
-          if (node.caseBlock.clauses.filter((switchCase) => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
-            this.#throwError(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.SwitchStatement,
             cases: this.convertChildren(node.caseBlock.clauses),
@@ -183780,9 +184151,6 @@ var require_convert = __commonJS((exports) => {
             test: node.kind === SyntaxKind.CaseClause ? this.convertChild(node.expression) : null
           });
         case SyntaxKind.ThrowStatement:
-          if (node.expression.end === node.expression.pos) {
-            this.#throwError(node, "A throw statement must throw an expression.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.ThrowStatement,
             argument: this.convertChild(node.expression)
@@ -183795,9 +184163,6 @@ var require_convert = __commonJS((exports) => {
             handler: this.convertChild(node.catchClause)
           });
         case SyntaxKind.CatchClause:
-          if (node.variableDeclaration?.initializer) {
-            this.#throwError(node.variableDeclaration.initializer, "Catch clause variable cannot have an initializer.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.CatchClause,
             body: this.convertChild(node.block),
@@ -183824,7 +184189,6 @@ var require_convert = __commonJS((exports) => {
             update: this.convertChild(node.incrementor)
           });
         case SyntaxKind.ForInStatement:
-          this.#checkForStatementDeclaration(node.initializer, node.kind);
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.ForInStatement,
             body: this.convertChild(node.statement),
@@ -183832,7 +184196,6 @@ var require_convert = __commonJS((exports) => {
             right: this.convertChild(node.expression)
           });
         case SyntaxKind.ForOfStatement: {
-          this.#checkForStatementDeclaration(node.initializer, node.kind);
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.ForOfStatement,
             await: node.awaitModifier?.kind === SyntaxKind.AwaitKeyword,
@@ -183845,17 +184208,6 @@ var require_convert = __commonJS((exports) => {
           const isDeclare = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
           const isAsync = (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node);
           const isGenerator = !!node.asteriskToken;
-          if (isDeclare) {
-            if (node.body) {
-              this.#throwError(node, "An implementation cannot be declared in ambient contexts.");
-            } else if (isAsync) {
-              this.#throwError(node, "'async' modifier cannot be used in an ambient context.");
-            } else if (isGenerator) {
-              this.#throwError(node, "Generators are not allowed in an ambient context.");
-            }
-          } else if (!node.body && isGenerator) {
-            this.#throwError(node, "A function signature cannot be declared as a generator.");
-          }
           const result = this.createNode(node, {
             type: !node.body ? ts_estree_1.AST_NODE_TYPES.TSDeclareFunction : ts_estree_1.AST_NODE_TYPES.FunctionDeclaration,
             async: isAsync,
@@ -183866,49 +184218,12 @@ var require_convert = __commonJS((exports) => {
             id: this.convertChild(node.name),
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           return this.fixExports(node, result);
         }
         case SyntaxKind.VariableDeclaration: {
           const hasExclamationToken = !!node.exclamationToken;
-          if (hasExclamationToken) {
-            if (node.initializer) {
-              this.#throwError(node, "Declarations with initializers cannot also have definite assignment assertions.");
-            } else if (node.name.kind !== SyntaxKind.Identifier || !node.type) {
-              this.#throwError(node, "Declarations with definite assignment assertions must also have type annotations.");
-            }
-          }
-          if (node.parent.kind === SyntaxKind.VariableDeclarationList) {
-            const variableDeclarationList = node.parent;
-            const kind = (0, node_utils_1.getDeclarationKind)(variableDeclarationList);
-            if ((variableDeclarationList.parent.kind === SyntaxKind.ForInStatement || variableDeclarationList.parent.kind === SyntaxKind.ForStatement) && (kind === "using" || kind === "await using")) {
-              if (!node.initializer) {
-                this.#throwError(node, `'${kind}' declarations may not be initialized in for statement.`);
-              }
-              if (node.name.kind !== SyntaxKind.Identifier) {
-                this.#throwError(node.name, `'${kind}' declarations may not have binding patterns.`);
-              }
-            }
-            if (variableDeclarationList.parent.kind === SyntaxKind.VariableStatement) {
-              const variableStatement = variableDeclarationList.parent;
-              if (kind === "using" || kind === "await using") {
-                if (!node.initializer) {
-                  this.#throwError(node, `'${kind}' declarations must be initialized.`);
-                }
-                if (node.name.kind !== SyntaxKind.Identifier) {
-                  this.#throwError(node.name, `'${kind}' declarations may not have binding patterns.`);
-                }
-              }
-              const hasDeclareKeyword = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, variableStatement);
-              if ((hasDeclareKeyword || ["await using", "const", "using"].includes(kind)) && hasExclamationToken) {
-                this.#throwError(node, `A definite assignment assertion '!' is not permitted in this context.`);
-              }
-              if (hasDeclareKeyword && node.initializer && (["let", "var"].includes(kind) || node.type)) {
-                this.#throwError(node, `Initializers are not permitted in ambient contexts.`);
-              }
-            }
-          }
           const init = this.convertChild(node.initializer);
           const id = this.convertBindingNameWithTypeAnnotation(node.name, node.type, node);
           return this.createNode(node, {
@@ -183920,9 +184235,6 @@ var require_convert = __commonJS((exports) => {
         }
         case SyntaxKind.VariableStatement: {
           const declarations = node.declarationList.declarations;
-          if (!declarations.length) {
-            this.#throwError(node, "A variable declaration list must have at least one variable declarator.");
-          }
           const result = this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.VariableDeclaration,
             declarations: this.convertChildren(declarations),
@@ -183974,26 +184286,12 @@ var require_convert = __commonJS((exports) => {
               typeAnnotation: undefined
             });
           }
-          const properties = [];
-          for (const property of node.properties) {
-            if ((property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor || property.kind === SyntaxKind.MethodDeclaration) && !property.body) {
-              this.#throwError(property.end - 1, "'{' expected.");
-            }
-            properties.push(this.convertChild(property));
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.ObjectExpression,
-            properties
+            properties: this.convertChildren(node.properties)
           });
         }
         case SyntaxKind.PropertyAssignment: {
-          const { exclamationToken, questionToken } = node;
-          if (questionToken) {
-            this.#throwError(questionToken, "A property assignment cannot have a question token.");
-          }
-          if (exclamationToken) {
-            this.#throwError(exclamationToken, "A property assignment cannot have an exclamation token.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.Property,
             computed: (0, node_utils_1.isComputedProperty)(node.name),
@@ -184006,16 +184304,6 @@ var require_convert = __commonJS((exports) => {
           });
         }
         case SyntaxKind.ShorthandPropertyAssignment: {
-          const { exclamationToken, modifiers, questionToken } = node;
-          if (modifiers) {
-            this.#throwError(modifiers[0], "A shorthand property assignment cannot have modifiers.");
-          }
-          if (questionToken) {
-            this.#throwError(questionToken, "A shorthand property assignment cannot have a question token.");
-          }
-          if (exclamationToken) {
-            this.#throwError(exclamationToken, "A shorthand property assignment cannot have an exclamation token.");
-          }
           if (node.objectAssignmentInitializer) {
             return this.createNode(node, {
               type: ts_estree_1.AST_NODE_TYPES.Property,
@@ -184050,12 +184338,6 @@ var require_convert = __commonJS((exports) => {
           return this.convertChild(node.expression);
         case SyntaxKind.PropertyDeclaration: {
           const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
-          if (isAbstract && node.initializer) {
-            this.#throwError(node.initializer, `Abstract property cannot have an initializer.`);
-          }
-          if (node.name.kind === SyntaxKind.StringLiteral && node.name.text === "constructor") {
-            this.#throwError(node.name, "Classes may not have a field named 'constructor'.");
-          }
           const isAccessor = (0, node_utils_1.hasModifier)(SyntaxKind.AccessorKeyword, node);
           const type = (() => {
             if (isAccessor) {
@@ -184093,10 +184375,6 @@ var require_convert = __commonJS((exports) => {
           }
         }
         case SyntaxKind.MethodDeclaration: {
-          const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
-          if (isAbstract && node.body) {
-            this.#throwError(node.name, node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor ? "An abstract accessor cannot have an implementation." : `Method '${(0, node_utils_1.declarationNameToString)(node.name, this.ast)}' cannot have an implementation because it is marked abstract.`);
-          }
           const method = this.createNode(node, {
             type: !node.body ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression : ts_estree_1.AST_NODE_TYPES.FunctionExpression,
             range: [node.parameters.pos - 1, node.end],
@@ -184108,7 +184386,7 @@ var require_convert = __commonJS((exports) => {
             id: null,
             params: [],
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           if (method.typeParameters) {
             this.fixParentLocation(method, method.typeParameters.range);
@@ -184127,6 +184405,7 @@ var require_convert = __commonJS((exports) => {
               value: method
             });
           } else {
+            const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
             method.params = this.convertParameters(node.parameters);
             const methodDefinitionType = isAbstract ? ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition : ts_estree_1.AST_NODE_TYPES.MethodDefinition;
             result = this.createNode(node, {
@@ -184165,7 +184444,7 @@ var require_convert = __commonJS((exports) => {
             id: null,
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           if (constructor.typeParameters) {
             this.fixParentLocation(constructor, constructor.typeParameters.range);
@@ -184210,7 +184489,7 @@ var require_convert = __commonJS((exports) => {
             id: this.convertChild(node.name),
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
         }
         case SyntaxKind.SuperKeyword:
@@ -184305,7 +184584,7 @@ var require_convert = __commonJS((exports) => {
             id: null,
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
         }
         case SyntaxKind.YieldExpression:
@@ -184347,14 +184626,11 @@ var require_convert = __commonJS((exports) => {
           return result;
         }
         case SyntaxKind.TaggedTemplateExpression: {
-          if (node.tag.flags & ts.NodeFlags.OptionalChain) {
-            this.#throwError(node, "Tagged template expressions are not permitted in an optional chain.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TaggedTemplateExpression,
             quasi: this.convertChild(node.template),
             tag: this.convertChild(node.tag),
-            typeArguments: node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+            typeArguments: this.convertTypeArguments(node)
           });
         }
         case SyntaxKind.TemplateHead:
@@ -184444,37 +184720,10 @@ var require_convert = __commonJS((exports) => {
           return result;
         }
         case SyntaxKind.ClassDeclaration:
-          if (!node.name && (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) || !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
-            this.#throwError(node, "A class declaration without the 'default' modifier must have a name.");
-          }
         case SyntaxKind.ClassExpression: {
-          const heritageClauses = node.heritageClauses ?? [];
           const classNodeType = node.kind === SyntaxKind.ClassDeclaration ? ts_estree_1.AST_NODE_TYPES.ClassDeclaration : ts_estree_1.AST_NODE_TYPES.ClassExpression;
-          let extendsClause;
-          let implementsClause;
-          for (const heritageClause of heritageClauses) {
-            const { token, types } = heritageClause;
-            if (types.length === 0) {
-              this.#throwError(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
-            }
-            if (token === SyntaxKind.ExtendsKeyword) {
-              if (extendsClause) {
-                this.#throwError(heritageClause, "'extends' clause already seen.");
-              }
-              if (implementsClause) {
-                this.#throwError(heritageClause, "'extends' clause must precede 'implements' clause.");
-              }
-              if (types.length > 1) {
-                this.#throwError(types[1], "Classes can only extend a single class.");
-              }
-              extendsClause ??= heritageClause;
-            } else if (token === SyntaxKind.ImplementsKeyword) {
-              if (implementsClause) {
-                this.#throwError(heritageClause, "'implements' clause already seen.");
-              }
-              implementsClause ??= heritageClause;
-            }
-          }
+          const extendsClause = node.heritageClauses?.find((heritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword);
+          const implementsClause = node.heritageClauses?.find((heritageClause) => heritageClause.token === SyntaxKind.ImplementsKeyword);
           const result = this.createNode(node, {
             type: classNodeType,
             abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
@@ -184489,10 +184738,10 @@ var require_convert = __commonJS((exports) => {
             implements: this.convertChildren(implementsClause?.types ?? []),
             superClass: extendsClause?.types[0] ? this.convertChild(extendsClause.types[0].expression) : null,
             superTypeArguments: undefined,
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           if (extendsClause?.types[0]?.typeArguments) {
-            result.superTypeArguments = this.convertTypeArgumentsToTypeParameterInstantiation(extendsClause.types[0].typeArguments, extendsClause.types[0]);
+            result.superTypeArguments = this.convertTypeArguments(extendsClause.types[0]);
           }
           return this.fixExports(node, result);
         }
@@ -184502,7 +184751,6 @@ var require_convert = __commonJS((exports) => {
             body: this.convertBodyExpressions(node.statements, node)
           });
         case SyntaxKind.ImportDeclaration: {
-          this.assertModuleSpecifier(node, false);
           const result = this.createNode(node, this.#withDeprecatedAliasGetter({
             type: ts_estree_1.AST_NODE_TYPES.ImportDeclaration,
             attributes: this.convertImportAttributes(node),
@@ -184552,7 +184800,6 @@ var require_convert = __commonJS((exports) => {
         }
         case SyntaxKind.ExportDeclaration: {
           if (node.exportClause?.kind === SyntaxKind.NamedExports) {
-            this.assertModuleSpecifier(node, true);
             return this.createNode(node, this.#withDeprecatedAliasGetter({
               type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
               attributes: this.convertImportAttributes(node),
@@ -184562,7 +184809,6 @@ var require_convert = __commonJS((exports) => {
               specifiers: this.convertChildren(node.exportClause.elements, node)
             }, "assertions", "attributes", true));
           }
-          this.assertModuleSpecifier(node, false);
           return this.createNode(node, this.#withDeprecatedAliasGetter({
             type: ts_estree_1.AST_NODE_TYPES.ExportAllDeclaration,
             attributes: this.convertImportAttributes(node),
@@ -184573,9 +184819,6 @@ var require_convert = __commonJS((exports) => {
         }
         case SyntaxKind.ExportSpecifier: {
           const local = node.propertyName ?? node.name;
-          if (local.kind === SyntaxKind.StringLiteral && parent.kind === SyntaxKind.ExportDeclaration && parent.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-            this.#throwError(local, "A string literal cannot be used as a local exported binding without `from`.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.ExportSpecifier,
             exported: this.convertChild(node.name),
@@ -184599,9 +184842,6 @@ var require_convert = __commonJS((exports) => {
         case SyntaxKind.PostfixUnaryExpression: {
           const operator = (0, node_utils_1.getTextForTokenKind)(node.operator);
           if (operator === "++" || operator === "--") {
-            if (!(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
-              this.#throwError(node.operand, "Invalid left-hand side expression in unary operation");
-            }
             return this.createNode(node, {
               type: ts_estree_1.AST_NODE_TYPES.UpdateExpression,
               argument: this.convertChild(node.operand),
@@ -184644,11 +184884,6 @@ var require_convert = __commonJS((exports) => {
             typeAnnotation: this.convertChild(node.type)
           });
         case SyntaxKind.BinaryExpression: {
-          if (node.operatorToken.kind !== SyntaxKind.InKeyword && node.left.kind === SyntaxKind.PrivateIdentifier) {
-            this.#throwError(node.left, "Private identifiers cannot appear on the right-hand-side of an 'in' expression.");
-          } else if (node.right.kind === SyntaxKind.PrivateIdentifier) {
-            this.#throwError(node.right, "Private identifiers are only allowed on the left-hand-side of an 'in' expression.");
-          }
           if ((0, node_utils_1.isComma)(node.operatorToken)) {
             const result = this.createNode(node, {
               type: ts_estree_1.AST_NODE_TYPES.SequenceExpression,
@@ -184708,9 +184943,6 @@ var require_convert = __commonJS((exports) => {
         }
         case SyntaxKind.CallExpression: {
           if (node.expression.kind === SyntaxKind.ImportKeyword) {
-            if (node.arguments.length !== 1 && node.arguments.length !== 2) {
-              this.#throwError(node.arguments[2] ?? node, "Dynamic import requires exactly one or two arguments.");
-            }
             return this.createNode(node, this.#withDeprecatedAliasGetter({
               type: ts_estree_1.AST_NODE_TYPES.ImportExpression,
               options: node.arguments[1] ? this.convertChild(node.arguments[1]) : null,
@@ -184719,7 +184951,7 @@ var require_convert = __commonJS((exports) => {
           }
           const callee = this.convertChild(node.expression);
           const args = this.convertChildren(node.arguments);
-          const typeArguments = node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+          const typeArguments = this.convertTypeArguments(node);
           const result = this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.CallExpression,
             arguments: args,
@@ -184730,7 +184962,7 @@ var require_convert = __commonJS((exports) => {
           return this.convertChainExpression(result, node);
         }
         case SyntaxKind.NewExpression: {
-          const typeArguments = node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+          const typeArguments = this.convertTypeArguments(node);
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.NewExpression,
             arguments: this.convertChildren(node.arguments ?? []),
@@ -184860,7 +185092,7 @@ var require_convert = __commonJS((exports) => {
               attributes: this.convertChildren(node.attributes.properties),
               name: this.convertJSXTagName(node.tagName, node),
               selfClosing: true,
-              typeArguments: node.typeArguments ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node) : undefined
+              typeArguments: this.convertTypeArguments(node)
             })
           });
         }
@@ -184870,7 +185102,7 @@ var require_convert = __commonJS((exports) => {
             attributes: this.convertChildren(node.attributes.properties),
             name: this.convertJSXTagName(node.tagName, node),
             selfClosing: false,
-            typeArguments: node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+            typeArguments: this.convertTypeArguments(node)
           });
         }
         case SyntaxKind.JsxClosingElement:
@@ -184935,7 +185167,7 @@ var require_convert = __commonJS((exports) => {
         case SyntaxKind.TypeReference:
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TSTypeReference,
-            typeArguments: node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+            typeArguments: this.convertTypeArguments(node),
             typeName: this.convertChild(node.typeName)
           });
         case SyntaxKind.TypeParameter: {
@@ -185008,12 +185240,9 @@ var require_convert = __commonJS((exports) => {
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery,
             exprName: this.convertChild(node.exprName),
-            typeArguments: node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+            typeArguments: this.convertTypeArguments(node)
           });
         case SyntaxKind.MappedType: {
-          if (node.members && node.members.length > 0) {
-            this.#throwError(node.members[0], "A mapped type may not declare properties or methods.");
-          }
           return this.createNode(node, this.#withDeprecatedGetter({
             type: ts_estree_1.AST_NODE_TYPES.TSMappedType,
             constraint: this.convertChild(node.typeParameter.constraint),
@@ -185032,7 +185261,7 @@ var require_convert = __commonJS((exports) => {
             declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
             id: this.convertChild(node.name),
             typeAnnotation: this.convertChild(node.type),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           return this.fixExports(node, result);
         }
@@ -185040,10 +185269,6 @@ var require_convert = __commonJS((exports) => {
           return this.convertMethodSignature(node);
         }
         case SyntaxKind.PropertySignature: {
-          const { initializer } = node;
-          if (initializer) {
-            this.#throwError(initializer, "A property signature cannot have an initializer.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TSPropertySignature,
             accessibility: (0, node_utils_1.getTSNodeAccessibility)(node),
@@ -185071,15 +185296,10 @@ var require_convert = __commonJS((exports) => {
             abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
         }
-        case SyntaxKind.FunctionType: {
-          const { modifiers } = node;
-          if (modifiers) {
-            this.#throwError(modifiers[0], "A function type cannot have modifiers.");
-          }
-        }
+        case SyntaxKind.FunctionType:
         case SyntaxKind.ConstructSignature:
         case SyntaxKind.CallSignature: {
           const type = node.kind === SyntaxKind.ConstructSignature ? ts_estree_1.AST_NODE_TYPES.TSConstructSignatureDeclaration : node.kind === SyntaxKind.CallSignature ? ts_estree_1.AST_NODE_TYPES.TSCallSignatureDeclaration : ts_estree_1.AST_NODE_TYPES.TSFunctionType;
@@ -185087,7 +185307,7 @@ var require_convert = __commonJS((exports) => {
             type,
             params: this.convertParameters(node.parameters),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
         }
         case SyntaxKind.ExpressionWithTypeArguments: {
@@ -185096,28 +185316,11 @@ var require_convert = __commonJS((exports) => {
           return this.createNode(node, {
             type,
             expression: this.convertChild(node.expression),
-            typeArguments: node.typeArguments && this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+            typeArguments: this.convertTypeArguments(node)
           });
         }
         case SyntaxKind.InterfaceDeclaration: {
-          const interfaceHeritageClauses = node.heritageClauses ?? [];
-          const interfaceExtends = [];
-          let seenExtendsClause = false;
-          for (const heritageClause of interfaceHeritageClauses) {
-            if (heritageClause.token !== SyntaxKind.ExtendsKeyword) {
-              this.#throwError(heritageClause, heritageClause.token === SyntaxKind.ImplementsKeyword ? "Interface declaration cannot have 'implements' clause." : "Unexpected token.");
-            }
-            if (seenExtendsClause) {
-              this.#throwError(heritageClause, "'extends' clause already seen.");
-            }
-            seenExtendsClause = true;
-            for (const heritageType of heritageClause.types) {
-              if (!isEntityNameExpression(heritageType.expression) || ts.isOptionalChain(heritageType.expression)) {
-                this.#throwError(heritageType, "Interface declaration can only extend an identifier/qualified name with optional type arguments.");
-              }
-              interfaceExtends.push(this.convertChild(heritageType, node));
-            }
-          }
+          const interfaceExtends = node.heritageClauses?.flatMap((heritageClause) => heritageClause.token === SyntaxKind.ExtendsKeyword ? heritageClause.types.map((heritageType) => this.convertChild(heritageType, node)) : []) ?? [];
           const result = this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration,
             body: this.createNode(node, {
@@ -185128,7 +185331,7 @@ var require_convert = __commonJS((exports) => {
             declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
             extends: interfaceExtends,
             id: this.convertChild(node.name),
-            typeParameters: node.typeParameters && this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+            typeParameters: this.convertTypeParameters(node)
           });
           return this.fixExports(node, result);
         }
@@ -185207,7 +185410,7 @@ var require_convert = __commonJS((exports) => {
             options,
             qualifier: this.convertChild(node.qualifier),
             source,
-            typeArguments: node.typeArguments ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node) : null
+            typeArguments: this.convertTypeArguments(node) ?? null
           }, "argument", "source", argument));
           if (node.isTypeOf) {
             return this.createNode(node, {
@@ -185235,12 +185438,6 @@ var require_convert = __commonJS((exports) => {
         }
         case SyntaxKind.EnumMember: {
           const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
-          if (computed) {
-            this.#throwError(node.name, "Computed property names are not allowed in enums.");
-          }
-          if (node.name.kind === SyntaxKind.NumericLiteral || node.name.kind === SyntaxKind.BigIntLiteral) {
-            this.#throwError(node.name, "An enum member cannot have a numeric name.");
-          }
           return this.createNode(node, this.#withDeprecatedGetter({
             type: ts_estree_1.AST_NODE_TYPES.TSEnumMember,
             id: this.convertChild(node.name),
@@ -185253,19 +185450,11 @@ var require_convert = __commonJS((exports) => {
             type: ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration,
             ...(() => {
               if (node.flags & ts.NodeFlags.GlobalAugmentation) {
-                const id = this.convertChild(node.name);
-                const body = this.convertChild(node.body);
-                if (body == null || body.type === ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration) {
-                  this.#throwError(node.body ?? node, "Expected a valid module body");
-                }
-                if (id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                  this.#throwError(node.name, "global module augmentation must have an Identifier id");
-                }
                 return {
-                  body,
+                  body: this.convertChild(node.body),
                   declare: false,
                   global: false,
-                  id,
+                  id: this.convertChild(node.name),
                   kind: "global"
                 };
               }
@@ -185279,12 +185468,6 @@ var require_convert = __commonJS((exports) => {
                   id: this.convertChild(node.name)
                 };
               }
-              if (node.body == null) {
-                this.#throwError(node, "Expected a module body");
-              }
-              if (node.name.kind !== ts.SyntaxKind.Identifier) {
-                this.#throwError(node.name, "`namespace`s must have an Identifier id");
-              }
               let name = this.createNode(node.name, {
                 type: ts_estree_1.AST_NODE_TYPES.Identifier,
                 range: [node.name.getStart(this.ast), node.name.getEnd()],
@@ -185382,9 +185565,6 @@ var require_convert = __commonJS((exports) => {
           }));
         }
         case SyntaxKind.ExternalModuleReference: {
-          if (node.expression.kind !== SyntaxKind.StringLiteral) {
-            this.#throwError(node.expression, "String literal expected.");
-          }
           return this.createNode(node, {
             type: ts_estree_1.AST_NODE_TYPES.TSExternalModuleReference,
             expression: this.convertChild(node.expression)
@@ -185501,10 +185681,10 @@ var require_convert = __commonJS((exports) => {
         result.typeAnnotation = node.type && "kind" in node.type && ts.isTypeNode(node.type) ? this.convertTypeAnnotation(node.type, node) : null;
       }
       if ("typeArguments" in node) {
-        result.typeArguments = node.typeArguments && "pos" in node.typeArguments ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node) : null;
+        result.typeArguments = node.typeArguments && "pos" in node.typeArguments ? this.convertTypeArguments(node) : null;
       }
       if ("typeParameters" in node) {
-        result.typeParameters = node.typeParameters && "pos" in node.typeParameters ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters) : null;
+        result.typeParameters = node.typeParameters && "pos" in node.typeParameters ? this.convertTypeParameters(node) : null;
       }
       const decorators = (0, getModifiers_1.getDecorators)(node);
       if (decorators?.length) {
@@ -187683,22 +187863,18 @@ var require_convert_comments = __commonJS((exports) => {
   var ts = __importStar(require_typescript());
   var node_utils_1 = require_node_utils();
   var ts_estree_1 = require_ts_estree2();
-  function convertComments(ast, code) {
-    const comments = [];
-    tsutils.forEachComment(ast, (_, comment) => {
-      const type = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia ? ts_estree_1.AST_TOKEN_TYPES.Line : ts_estree_1.AST_TOKEN_TYPES.Block;
-      const range = [comment.pos, comment.end];
+  function convertComments(ast) {
+    return Array.from(tsutils.iterateComments(ast), ({ end, kind, pos, value }) => {
+      const type = kind === ts.SyntaxKind.SingleLineCommentTrivia ? ts_estree_1.AST_TOKEN_TYPES.Line : ts_estree_1.AST_TOKEN_TYPES.Block;
+      const range = [pos, end];
       const loc = (0, node_utils_1.getLocFor)(range, ast);
-      const textStart = range[0] + 2;
-      const textEnd = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia ? range[1] : range[1] - 2;
-      comments.push({
+      return {
         type,
         loc,
         range,
-        value: code.slice(textStart, textEnd)
-      });
-    }, ast);
-    return comments;
+        value
+      };
+    });
   }
 });
 
@@ -187795,7 +187971,7 @@ var require_ast_converter = __commonJS((exports) => {
       estree.tokens = (0, node_utils_1.convertTokens)(ast);
     }
     if (parseSettings.comment) {
-      estree.comments = (0, convert_comments_1.convertComments)(ast, parseSettings.codeFullText);
+      estree.comments = (0, convert_comments_1.convertComments)(ast);
     }
     const astMaps = instance.getASTMaps();
     return { astMaps, estree };
@@ -188050,7 +188226,7 @@ ${relativeProjects.map((project) => `- ${project}`).join(`
         `Either:`,
         `- Switch to \`parserOptions.projectService\``,
         `- Use an ESLint-specific TSConfig`,
-        `See the typescript-eslint docs for more info: https://typescript-eslint.io/troubleshooting/typed-linting#are-typescript-project-references-supported`
+        `See the typescript-eslint docs for more info: https://tseslint.com/are-project-references-supported`
       ];
     }
     const { extraFileExtensions } = parseSettings;
@@ -188087,7 +188263,7 @@ ${relativeProjects.map((project) => `- ${project}`).join(`
       `- Change ESLint's list of included files to not include this file`,
       `- Change ${describedSpecifiers} to include this file`,
       `- Create a new TSConfig that includes this file and include it in your parserOptions.project`,
-      `See the typescript-eslint docs for more info: https://typescript-eslint.io/troubleshooting/typed-linting#i-get-errors-telling-me-eslint-was-configured-to-run--however-that-tsconfig-does-not--none-of-those-tsconfigs-include-this-file`
+      `See the typescript-eslint docs for more info: https://tseslint.com/none-of-those-tsconfigs-include-this-file`
     ];
   }
 });
@@ -188362,7 +188538,7 @@ var require_createProjectService = __commonJS((exports) => {
   var createStubFileWatcher = () => ({
     close: doNothing
   });
-  function createProjectService({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
+  function createProjectService({ host, jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
     const options = {
       defaultProject: "tsconfig.json",
       ...optionsRaw
@@ -188383,7 +188559,8 @@ var require_createProjectService = __commonJS((exports) => {
           },
           module: undefined
         })
-      }
+      },
+      ...host
     };
     const logger = {
       close: doNothing,
@@ -188480,7 +188657,7 @@ var require_validateDefaultProjectForFilesGlob = __commonJS((exports) => {
 
 Having many files run with the default project is known to cause performance issues and slow down linting.
 
-See https://typescript-eslint.io/troubleshooting/typed-linting#allowdefaultproject-glob-too-wide
+See https://tseslint.com/allowdefaultproject-glob-too-wide
 `;
   function validateDefaultProjectForFilesGlob(allowDefaultProject) {
     if (!allowDefaultProject?.length) {
@@ -188522,7 +188699,7 @@ var require_candidateTSConfigRootDirs = __commonJS((exports) => {
           "No tsconfigRootDir was set, and multiple candidate TSConfigRootDirs are present:",
           ...entries.map((candidate) => ` - ${candidate}`),
           "You'll need to explicitly set tsconfigRootDir in your parser options.",
-          "See: https://typescript-eslint.io/packages/parser/#tsconfigrootdir"
+          "See: https://tseslint.com/parser-tsconfigrootdir"
         ].join(`
 `));
     }
@@ -191132,7 +191309,7 @@ var require_resolveProjectList = __commonJS((exports) => {
 var require_package2 = __commonJS((exports, module) => {
   module.exports = {
     name: "@typescript-eslint/typescript-estree",
-    version: "8.51.0",
+    version: "8.53.0",
     description: "A parser that converts TypeScript source code into an ESTree compatible form",
     files: [
       "dist",
@@ -191184,23 +191361,23 @@ var require_package2 = __commonJS((exports, module) => {
       typecheck: "yarn run -BT nx typecheck"
     },
     dependencies: {
-      "@typescript-eslint/project-service": "8.51.0",
-      "@typescript-eslint/tsconfig-utils": "8.51.0",
-      "@typescript-eslint/types": "8.51.0",
-      "@typescript-eslint/visitor-keys": "8.51.0",
-      debug: "^4.3.4",
-      minimatch: "^9.0.4",
-      semver: "^7.6.0",
+      "@typescript-eslint/project-service": "8.53.0",
+      "@typescript-eslint/tsconfig-utils": "8.53.0",
+      "@typescript-eslint/types": "8.53.0",
+      "@typescript-eslint/visitor-keys": "8.53.0",
+      debug: "^4.4.3",
+      minimatch: "^9.0.5",
+      semver: "^7.7.3",
       tinyglobby: "^0.2.15",
-      "ts-api-utils": "^2.2.0"
+      "ts-api-utils": "^2.4.0"
     },
     devDependencies: {
-      "@vitest/coverage-v8": "^3.1.3",
+      "@vitest/coverage-v8": "^3.2.4",
       eslint: "*",
       glob: "*",
       rimraf: "*",
       typescript: "*",
-      vitest: "^3.1.3"
+      vitest: "^3.2.4"
     },
     peerDependencies: {
       typescript: ">=4.8.4 <6.0.0"
@@ -193588,7 +193765,7 @@ var require_parser2 = __commonJS((exports) => {
 var require_package3 = __commonJS((exports, module) => {
   module.exports = {
     name: "@typescript-eslint/parser",
-    version: "8.51.0",
+    version: "8.53.0",
     description: "An ESLint custom parser which leverages TypeScript ESTree",
     files: [
       "dist",
@@ -193639,19 +193816,19 @@ var require_package3 = __commonJS((exports, module) => {
       typescript: ">=4.8.4 <6.0.0"
     },
     dependencies: {
-      "@typescript-eslint/scope-manager": "8.51.0",
-      "@typescript-eslint/types": "8.51.0",
-      "@typescript-eslint/typescript-estree": "8.51.0",
-      "@typescript-eslint/visitor-keys": "8.51.0",
-      debug: "^4.3.4"
+      "@typescript-eslint/scope-manager": "8.53.0",
+      "@typescript-eslint/types": "8.53.0",
+      "@typescript-eslint/typescript-estree": "8.53.0",
+      "@typescript-eslint/visitor-keys": "8.53.0",
+      debug: "^4.4.3"
     },
     devDependencies: {
-      "@vitest/coverage-v8": "^3.1.3",
+      "@vitest/coverage-v8": "^3.2.4",
       eslint: "*",
       glob: "*",
       rimraf: "*",
       typescript: "*",
-      vitest: "^3.1.3"
+      vitest: "^3.2.4"
     },
     funding: {
       type: "opencollective",
@@ -193851,6 +194028,7 @@ var require_all = __commonJS((exports, module) => {
       "no-return-await": "off",
       "@typescript-eslint/return-await": "error",
       "@typescript-eslint/strict-boolean-expressions": "error",
+      "@typescript-eslint/strict-void-return": "error",
       "@typescript-eslint/switch-exhaustiveness-check": "error",
       "@typescript-eslint/triple-slash-reference": "error",
       "@typescript-eslint/unbound-method": "error",
@@ -193931,6 +194109,7 @@ var require_disable_type_checked = __commonJS((exports, module) => {
       "@typescript-eslint/restrict-template-expressions": "off",
       "@typescript-eslint/return-await": "off",
       "@typescript-eslint/strict-boolean-expressions": "off",
+      "@typescript-eslint/strict-void-return": "off",
       "@typescript-eslint/switch-exhaustiveness-check": "off",
       "@typescript-eslint/unbound-method": "off",
       "@typescript-eslint/use-unknown-in-catch-callback-variable": "off"
@@ -194602,6 +194781,7 @@ var require_all2 = __commonJS((exports) => {
         "no-return-await": "off",
         "@typescript-eslint/return-await": "error",
         "@typescript-eslint/strict-boolean-expressions": "error",
+        "@typescript-eslint/strict-void-return": "error",
         "@typescript-eslint/switch-exhaustiveness-check": "error",
         "@typescript-eslint/triple-slash-reference": "error",
         "@typescript-eslint/unbound-method": "error",
@@ -194675,6 +194855,7 @@ var require_disable_type_checked2 = __commonJS((exports) => {
       "@typescript-eslint/restrict-template-expressions": "off",
       "@typescript-eslint/return-await": "off",
       "@typescript-eslint/strict-boolean-expressions": "off",
+      "@typescript-eslint/strict-void-return": "off",
       "@typescript-eslint/switch-exhaustiveness-check": "off",
       "@typescript-eslint/unbound-method": "off",
       "@typescript-eslint/use-unknown-in-catch-callback-variable": "off"
@@ -197583,7 +197764,7 @@ var require_getParserServices = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.getParserServices = getParserServices;
   var parserSeemsToBeTSESLint_1 = require_parserSeemsToBeTSESLint();
-  var ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://typescript-eslint.io/getting-started/typed-linting for enabling linting with type information.";
+  var ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information.";
   var ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.';
   function getParserServices(context, allowWithoutFullTypeInformation = false) {
     const parser = context.parserPath || context.languageOptions.parser?.meta?.name;
@@ -288119,6 +288300,36 @@ var require_createRule = __commonJS((exports) => {
   exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://typescript-eslint.io/rules/${name}`);
 });
 
+// ../../node_modules/@typescript-eslint/eslint-plugin/dist/util/getBaseTypesOfClassMember.js
+var require_getBaseTypesOfClassMember = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getBaseTypesOfClassMember = getBaseTypesOfClassMember;
+  function* getBaseTypesOfClassMember(services, memberNode) {
+    const memberTsNode = services.esTreeNodeToTSNodeMap.get(memberNode);
+    if (memberTsNode.name == null) {
+      return;
+    }
+    const checker = services.program.getTypeChecker();
+    const memberSymbol = checker.getSymbolAtLocation(memberTsNode.name);
+    if (memberSymbol == null) {
+      return;
+    }
+    const classNode = memberTsNode.parent;
+    for (const clauseNode of classNode.heritageClauses ?? []) {
+      for (const baseTypeNode of clauseNode.types) {
+        const baseType = checker.getTypeAtLocation(baseTypeNode);
+        const baseMemberSymbol = checker.getPropertyOfType(baseType, memberSymbol.name);
+        if (baseMemberSymbol == null) {
+          continue;
+        }
+        const baseMemberType = checker.getTypeOfSymbolAtLocation(baseMemberSymbol, memberTsNode);
+        const heritageToken = clauseNode.token;
+        yield { baseMemberType, baseType, heritageToken };
+      }
+    }
+  }
+});
+
 // ../../node_modules/@typescript-eslint/eslint-plugin/dist/util/getFixOrSuggest.js
 var require_getFixOrSuggest = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -291049,6 +291260,60 @@ var require_truthinessUtils = __commonJS((exports) => {
   exports.isPossiblyTruthy = isPossiblyTruthy;
 });
 
+// ../../node_modules/@typescript-eslint/eslint-plugin/dist/util/walkStatements.js
+var require_walkStatements = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.walkStatements = walkStatements;
+  var utils_1 = require_dist10();
+  function* walkStatements(body) {
+    for (const statement of body) {
+      switch (statement.type) {
+        case utils_1.AST_NODE_TYPES.BlockStatement: {
+          yield* walkStatements(statement.body);
+          continue;
+        }
+        case utils_1.AST_NODE_TYPES.SwitchStatement: {
+          for (const switchCase of statement.cases) {
+            yield* walkStatements(switchCase.consequent);
+          }
+          continue;
+        }
+        case utils_1.AST_NODE_TYPES.IfStatement: {
+          yield* walkStatements([statement.consequent]);
+          if (statement.alternate) {
+            yield* walkStatements([statement.alternate]);
+          }
+          continue;
+        }
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+        case utils_1.AST_NODE_TYPES.DoWhileStatement:
+        case utils_1.AST_NODE_TYPES.ForStatement:
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+        case utils_1.AST_NODE_TYPES.WithStatement:
+        case utils_1.AST_NODE_TYPES.LabeledStatement: {
+          yield* walkStatements([statement.body]);
+          continue;
+        }
+        case utils_1.AST_NODE_TYPES.TryStatement: {
+          yield* walkStatements([statement.block]);
+          if (statement.handler) {
+            yield* walkStatements([statement.handler.body]);
+          }
+          if (statement.finalizer) {
+            yield* walkStatements([statement.finalizer]);
+          }
+          continue;
+        }
+        default: {
+          yield statement;
+          continue;
+        }
+      }
+    }
+  }
+});
+
 // ../../node_modules/@typescript-eslint/eslint-plugin/dist/util/index.js
 var require_util3 = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
@@ -291078,6 +291343,7 @@ var require_util3 = __commonJS((exports) => {
   __exportStar(require_baseTypeUtils(), exports);
   __exportStar(require_collectUnusedVariables(), exports);
   __exportStar(require_createRule(), exports);
+  __exportStar(require_getBaseTypesOfClassMember(), exports);
   __exportStar(require_getFixOrSuggest(), exports);
   __exportStar(require_getFunctionHeadLoc(), exports);
   __exportStar(require_getOperatorPrecedence(), exports);
@@ -291104,6 +291370,7 @@ var require_util3 = __commonJS((exports) => {
   __exportStar(require_isHigherPrecedenceThanAwait(), exports);
   __exportStar(require_skipChainExpression(), exports);
   __exportStar(require_truthinessUtils(), exports);
+  __exportStar(require_walkStatements(), exports);
   __exportStar(require_dist11(), exports);
   exports.applyDefault = utils_1.ESLintUtils.applyDefault, exports.deepMerge = utils_1.ESLintUtils.deepMerge, exports.getParserServices = utils_1.ESLintUtils.getParserServices, exports.isObjectNotArray = utils_1.ESLintUtils.isObjectNotArray, exports.nullThrows = utils_1.ESLintUtils.nullThrows, exports.NullThrowsReasons = utils_1.ESLintUtils.NullThrowsReasons;
 });
@@ -297564,20 +297831,17 @@ var require_no_base_to_string = __commonJS((exports) => {
         if (checker.isArrayType(type)) {
           return collectArrayCertainty(type, new Set([...visited, type]));
         }
-        const toString = checker.getPropertyOfType(type, "toString") ?? checker.getPropertyOfType(type, "toLocaleString");
-        if (!toString) {
-          if (option.checkUnknown && type.flags === ts.TypeFlags.Unknown) {
-            return Usefulness.Sometimes;
-          }
-          return Usefulness.Always;
-        }
-        const declarations = toString.getDeclarations();
-        if (declarations == null || declarations.length !== 1) {
-          return Usefulness.Always;
+        switch (isToStringLikeFromObject(type)) {
+          case undefined:
+            if (option.checkUnknown && type.flags === ts.TypeFlags.Unknown) {
+              return Usefulness.Sometimes;
+            }
+            return Usefulness.Always;
+          case true:
+            return Usefulness.Never;
+          case false:
+            return Usefulness.Always;
         }
-        const declaration = declarations[0];
-        const isBaseToString = ts.isInterfaceDeclaration(declaration.parent) && declaration.parent.name.text === "Object";
-        return isBaseToString ? Usefulness.Never : Usefulness.Always;
       }
       function isBuiltInStringCall(node) {
         if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === "String" && node.arguments[0]) {
@@ -297587,6 +297851,30 @@ var require_no_base_to_string = __commonJS((exports) => {
         }
         return false;
       }
+      function isSymbolToPrimitiveMethod(node) {
+        return ts.isMethodSignature(node) && ts.isComputedPropertyName(node.name) && ts.isPropertyAccessExpression(node.name.expression) && ts.isIdentifier(node.name.expression.expression) && node.name.expression.expression.text === "Symbol" && ts.isIdentifier(node.name.expression.name) && node.name.expression.name.text === "toPrimitive" && checker.getSymbolAtLocation(node.name.expression.expression)?.valueDeclaration?.getSourceFile().hasNoDefaultLib;
+      }
+      function isToStringLikeFromObject(type) {
+        if (type.getProperties().some((property) => property.valueDeclaration && isSymbolToPrimitiveMethod(property.valueDeclaration))) {
+          return false;
+        }
+        let foundFallbackOnObject = false;
+        for (const propertyName of ["toLocaleString", "toString", "valueOf"]) {
+          const candidate = checker.getPropertyOfType(type, propertyName);
+          if (!candidate) {
+            continue;
+          }
+          const declarations = candidate.getDeclarations();
+          if (declarations?.length !== 1) {
+            continue;
+          }
+          if (!ts.isInterfaceDeclaration(declarations[0].parent) || declarations[0].parent.name.text !== "Object") {
+            return false;
+          }
+          foundFallbackOnObject = true;
+        }
+        return foundFallbackOnObject ? true : undefined;
+      }
       return {
         'AssignmentExpression[operator = "+="], BinaryExpression[operator = "+"]'(node) {
           const leftType = services.getTypeAtLocation(node.left);
@@ -307761,14 +308049,18 @@ var require_no_unsafe_call = __commonJS((exports) => {
         requiresTypeChecking: true
       },
       messages: {
-        unsafeCall: "Unsafe call of a(n) {{type}} typed value.",
+        errorCall: "Unsafe call of a type that could not be resolved.",
+        errorCallThis: "Unsafe call of a `this` type that could not be resolved.",
+        errorNew: "Unsafe construction of a type that could not be resolved.",
+        errorTemplateTag: "Unsafe use of a template tag whose type could not be resolved.",
+        unsafeCall: "Unsafe call of {{type}} typed value.",
         unsafeCallThis: [
-          "Unsafe call of a(n) {{type}} typed value. `this` is typed as {{type}}.",
+          "Unsafe call of {{type}} typed value. `this` is typed as {{type}}.",
           "You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function."
         ].join(`
 `),
-        unsafeNew: "Unsafe construction of a(n) {{type}} typed value.",
-        unsafeTemplateTag: "Unsafe use of a(n) {{type}} typed template tag."
+        unsafeNew: "Unsafe construction of {{type}} typed value.",
+        unsafeTemplateTag: "Unsafe use of {{type}} typed template tag."
       },
       schema: []
     },
@@ -307777,21 +308069,22 @@ var require_no_unsafe_call = __commonJS((exports) => {
       const services = (0, util_1.getParserServices)(context);
       const compilerOptions = services.program.getCompilerOptions();
       const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, "noImplicitThis");
-      function checkCall(node, reportingNode, messageId) {
+      function checkCall(node, reportingNode, unsafeMessageId, errorMessageId) {
         const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
         if ((0, util_1.isTypeAnyType)(type)) {
           if (!isNoImplicitThis) {
             const thisExpression = (0, util_1.getThisExpression)(node);
             if (thisExpression && (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-              messageId = "unsafeCallThis";
+              unsafeMessageId = "unsafeCallThis";
+              errorMessageId = "errorCallThis";
             }
           }
           const isErrorType = tsutils.isIntrinsicErrorType(type);
           context.report({
             node: reportingNode,
-            messageId,
+            messageId: isErrorType ? errorMessageId : unsafeMessageId,
             data: {
-              type: isErrorType ? "`error` type" : "`any`"
+              type: "an `any`"
             }
           });
           return;
@@ -307802,7 +308095,7 @@ var require_no_unsafe_call = __commonJS((exports) => {
             return;
           }
           const callSignatures = type.getCallSignatures();
-          if (messageId === "unsafeNew") {
+          if (unsafeMessageId === "unsafeNew") {
             if (callSignatures.some((signature) => !tsutils.isIntrinsicVoidType(signature.getReturnType()))) {
               return;
             }
@@ -307811,9 +308104,9 @@ var require_no_unsafe_call = __commonJS((exports) => {
           }
           context.report({
             node: reportingNode,
-            messageId,
+            messageId: unsafeMessageId,
             data: {
-              type: "`Function`"
+              type: "a `Function`"
             }
           });
           return;
@@ -307821,13 +308114,13 @@ var require_no_unsafe_call = __commonJS((exports) => {
       }
       return {
         "CallExpression > *.callee"(node) {
-          checkCall(node, node, "unsafeCall");
+          checkCall(node, node, "unsafeCall", "errorCall");
         },
         NewExpression(node) {
-          checkCall(node.callee, node, "unsafeNew");
+          checkCall(node.callee, node, "unsafeNew", "errorNew");
         },
         "TaggedTemplateExpression > *.tag"(node) {
-          checkCall(node, node, "unsafeTemplateTag");
+          checkCall(node, node, "unsafeTemplateTag", "errorTemplateTag");
         }
       };
     }
@@ -308235,10 +308528,6 @@ var require_no_unsafe_member_access = __commonJS((exports) => {
     State2[State2["Safe"] = 2] = "Safe";
     State2[State2["Chained"] = 3] = "Chained";
   })(State || (State = {}));
-  function createDataType(type) {
-    const isErrorType = tsutils.isIntrinsicErrorType(type);
-    return isErrorType ? "`error` typed" : "`any`";
-  }
   exports.default = (0, util_1.createRule)({
     name: "no-unsafe-member-access",
     meta: {
@@ -308249,8 +308538,15 @@ var require_no_unsafe_member_access = __commonJS((exports) => {
         requiresTypeChecking: true
       },
       messages: {
-        unsafeComputedMemberAccess: "Computed name {{property}} resolves to an {{type}} value.",
-        unsafeMemberExpression: "Unsafe member access {{property}} on an {{type}} value.",
+        errorComputedMemberAccess: "The type of computed name {{property}} cannot be resolved.",
+        errorMemberExpression: "Unsafe member access {{property}} on a type that cannot be resolved.",
+        errorThisMemberExpression: [
+          "Unsafe member access {{property}}. The type of `this` cannot be resolved.",
+          "You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function."
+        ].join(`
+`),
+        unsafeComputedMemberAccess: "Computed name {{property}} resolves to an `any` value.",
+        unsafeMemberExpression: "Unsafe member access {{property}} on an `any` value.",
         unsafeThisMemberExpression: [
           "Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.",
           "You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function."
@@ -308301,18 +308597,23 @@ var require_no_unsafe_member_access = __commonJS((exports) => {
         stateCache.set(node, state);
         if (state === State.Unsafe) {
           const propertyName = context.sourceCode.getText(node.property);
-          let messageId = "unsafeMemberExpression";
+          let messageId;
           if (!isNoImplicitThis) {
             const thisExpression = (0, util_1.getThisExpression)(node);
-            if (thisExpression && (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-              messageId = "unsafeThisMemberExpression";
+            if (thisExpression) {
+              const thisType = (0, util_1.getConstrainedTypeAtLocation)(services, thisExpression);
+              if ((0, util_1.isTypeAnyType)(thisType)) {
+                messageId = tsutils.isIntrinsicErrorType(thisType) ? "errorThisMemberExpression" : "unsafeThisMemberExpression";
+              }
             }
           }
+          if (!messageId) {
+            messageId = tsutils.isIntrinsicErrorType(type) ? "errorMemberExpression" : "unsafeMemberExpression";
+          }
           context.report({
             node: node.property,
             messageId,
             data: {
-              type: createDataType(type),
               property: node.computed ? `[${propertyName}]` : `.${propertyName}`
             }
           });
@@ -308333,9 +308634,8 @@ var require_no_unsafe_member_access = __commonJS((exports) => {
             const propertyName = context.sourceCode.getText(node);
             context.report({
               node,
-              messageId: "unsafeComputedMemberAccess",
+              messageId: tsutils.isIntrinsicErrorType(type) ? "errorComputedMemberAccess" : "unsafeComputedMemberAccess",
               data: {
-                type: createDataType(type),
                 property: `[${propertyName}]`
               }
             });
@@ -309335,6 +309635,42 @@ var require_no_unused_vars2 = __commonJS((exports) => {
   var utils_1 = require_dist10();
   var util_1 = require_util3();
   var referenceContainsTypeQuery_1 = require_referenceContainsTypeQuery();
+  var VariableType;
+  (function(VariableType2) {
+    VariableType2[VariableType2["ArrayDestructure"] = 0] = "ArrayDestructure";
+    VariableType2[VariableType2["CatchClause"] = 1] = "CatchClause";
+    VariableType2[VariableType2["ClassName"] = 2] = "ClassName";
+    VariableType2[VariableType2["FunctionName"] = 3] = "FunctionName";
+    VariableType2[VariableType2["ImportBinding"] = 4] = "ImportBinding";
+    VariableType2[VariableType2["ImplicitGlobalVariable"] = 5] = "ImplicitGlobalVariable";
+    VariableType2[VariableType2["Parameter"] = 6] = "Parameter";
+    VariableType2[VariableType2["TSEnumMember"] = 7] = "TSEnumMember";
+    VariableType2[VariableType2["TSEnumName"] = 8] = "TSEnumName";
+    VariableType2[VariableType2["TSModuleName"] = 9] = "TSModuleName";
+    VariableType2[VariableType2["Type"] = 10] = "Type";
+    VariableType2[VariableType2["Variable"] = 11] = "Variable";
+  })(VariableType || (VariableType = {}));
+  var isCommaToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ",",
+    tokenChar: ","
+  };
+  var isLeftCurlyToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === "{",
+    tokenChar: "{"
+  };
+  var isRightCurlyToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === "}",
+    tokenChar: "}"
+  };
+  function assertToken({ predicate, tokenChar }, token) {
+    if (token == null) {
+      throw new Error(`Expected a valid "${tokenChar}" token, but found no token`);
+    }
+    if (!predicate(token)) {
+      throw new Error(`Expected a valid "${tokenChar}" token, but got "${token.value}" instead`);
+    }
+    return token;
+  }
   exports.default = (0, util_1.createRule)({
     name: "no-unused-vars",
     meta: {
@@ -309344,7 +309680,11 @@ var require_no_unused_vars2 = __commonJS((exports) => {
         extendsBaseRule: true,
         recommended: "recommended"
       },
+      fixable: "code",
+      hasSuggestions: true,
       messages: {
+        removeUnusedImportDeclaration: "Remove unused import declaration.",
+        removeUnusedVar: 'Remove unused variable "{{varName}}".',
         unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
         usedIgnoredVar: "'{{varName}}' is marked as ignored but is used{{additional}}.",
         usedOnlyAsType: "'{{varName}}' is {{action}} but only used as a type{{additional}}."
@@ -309383,6 +309723,17 @@ var require_no_unused_vars2 = __commonJS((exports) => {
                   type: "string",
                   description: "Regular expressions of destructured array variable names to not check for usage."
                 },
+                enableAutofixRemoval: {
+                  type: "object",
+                  additionalProperties: false,
+                  description: "Configurable automatic fixes for different types of unused variables.",
+                  properties: {
+                    imports: {
+                      type: "boolean",
+                      description: "Whether to enable automatic removal of unused imports."
+                    }
+                  }
+                },
                 ignoreClassWithStaticInitBlock: {
                   type: "boolean",
                   description: "Whether to ignore classes with at least one static initialization block."
@@ -309417,10 +309768,94 @@ var require_no_unused_vars2 = __commonJS((exports) => {
     defaultOptions: [{}],
     create(context, [firstOption]) {
       const MODULE_DECL_CACHE = new Map;
+      const reportedUnusedVariables = new Set;
+      function areAllSpecifiersUnused(decl) {
+        return context.sourceCode.getDeclaredVariables(decl).every((variable) => {
+          return reportedUnusedVariables.has(variable);
+        });
+      }
+      const report = (unusedVar, opts) => {
+        reportedUnusedVariables.add(unusedVar);
+        const writeReferences = unusedVar.references.filter((ref) => ref.isWrite() && ref.from.variableScope === unusedVar.scope.variableScope);
+        const id = writeReferences.length ? writeReferences[writeReferences.length - 1].identifier : unusedVar.identifiers[0];
+        const { start } = id.loc;
+        const idLength = id.name.length;
+        const loc = {
+          start,
+          end: {
+            column: start.column + idLength,
+            line: start.line
+          }
+        };
+        const fixer = (() => {
+          const { messageId, fix, useAutofix } = (() => {
+            if (unusedVar.defs.length !== 1) {
+              return {};
+            }
+            const { type, def } = defToVariableType(unusedVar.defs[0]);
+            switch (type) {
+              case VariableType.ArrayDestructure:
+                return {};
+              case VariableType.CatchClause:
+                return {};
+              case VariableType.ClassName:
+                return {};
+              case VariableType.FunctionName:
+                return {};
+              case VariableType.ImportBinding:
+                return {
+                  ...getImportFixer(def),
+                  useAutofix: options.enableAutofixRemoval.imports
+                };
+              case VariableType.ImplicitGlobalVariable:
+                return {};
+              case VariableType.Parameter:
+                return {};
+              case VariableType.TSEnumMember:
+                return {};
+              case VariableType.TSEnumName:
+                return {};
+              case VariableType.TSModuleName:
+                return {};
+              case VariableType.Type:
+                return {};
+              case VariableType.Variable:
+                return {};
+            }
+          })();
+          if (!fix) {
+            return {};
+          }
+          if (useAutofix) {
+            return { fix };
+          }
+          const data = {
+            varName: unusedVar.name
+          };
+          return {
+            suggest: [
+              {
+                messageId: messageId ?? "removeUnusedVar",
+                data,
+                fix
+              }
+            ]
+          };
+        })();
+        context.report({
+          ...opts,
+          ...fixer,
+          loc,
+          node: id
+        });
+      };
       const options = (() => {
         const options2 = {
           args: "after-used",
           caughtErrors: "all",
+          enableAutofixRemoval: {
+            imports: false
+          },
           ignoreClassWithStaticInitBlock: false,
           ignoreRestSiblings: false,
           ignoreUsingDeclarations: false,
@@ -309449,40 +309884,136 @@ var require_no_unused_vars2 = __commonJS((exports) => {
           if (firstOption.destructuredArrayIgnorePattern) {
             options2.destructuredArrayIgnorePattern = new RegExp(firstOption.destructuredArrayIgnorePattern, "u");
           }
+          if (firstOption.enableAutofixRemoval) {
+            if (firstOption.enableAutofixRemoval.imports != null) {
+              options2.enableAutofixRemoval.imports = firstOption.enableAutofixRemoval.imports;
+            }
+          }
         }
         return options2;
       })();
+      function getImportFixer(def) {
+        switch (def.node.type) {
+          case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+            return {
+              messageId: "removeUnusedImportDeclaration",
+              fix: (fixer) => fixer.remove(def.node)
+            };
+          case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier: {
+            const importDecl = def.node.parent;
+            if (importDecl.specifiers.length === 1 || areAllSpecifiersUnused(importDecl)) {
+              return {
+                messageId: "removeUnusedImportDeclaration",
+                fix: (fixer) => fixer.remove(importDecl)
+              };
+            }
+            return {
+              messageId: "removeUnusedVar",
+              fix: (fixer) => {
+                const comma = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(def.node), util_1.NullThrowsReasons.MissingToken(",", "import specifier"));
+                assertToken(isCommaToken, comma);
+                return fixer.removeRange([
+                  Math.min(def.node.range[0], comma.range[0]),
+                  Math.max(def.node.range[1], comma.range[1])
+                ]);
+              }
+            };
+          }
+          case utils_1.AST_NODE_TYPES.ImportSpecifier: {
+            const importDecl = def.node.parent;
+            if (importDecl.specifiers.length === 1 || areAllSpecifiersUnused(importDecl)) {
+              return {
+                messageId: "removeUnusedImportDeclaration",
+                fix: (fixer) => fixer.remove(importDecl)
+              };
+            }
+            return {
+              messageId: "removeUnusedVar",
+              fix: (fixer) => {
+                const usedNamedSpecifiers = context.sourceCode.getDeclaredVariables(importDecl).map((variable) => {
+                  if (reportedUnusedVariables.has(variable)) {
+                    return null;
+                  }
+                  const specifier = variable.defs[0].node;
+                  if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                    return null;
+                  }
+                  return specifier;
+                }).filter((v) => v != null);
+                if (usedNamedSpecifiers.length === 0) {
+                  const leftCurly = assertToken(isLeftCurlyToken, context.sourceCode.getFirstToken(importDecl, isLeftCurlyToken.predicate));
+                  const leftToken = assertToken(isCommaToken, context.sourceCode.getTokenBefore(leftCurly));
+                  const rightToken = assertToken(isRightCurlyToken, context.sourceCode.getFirstToken(importDecl, isRightCurlyToken.predicate));
+                  return fixer.removeRange([
+                    leftToken.range[0],
+                    rightToken.range[1]
+                  ]);
+                }
+                const maybeComma = context.sourceCode.getTokenBefore(def.node);
+                const comma = maybeComma && isCommaToken.predicate(maybeComma) ? maybeComma : assertToken(isCommaToken, context.sourceCode.getTokenAfter(def.node));
+                return fixer.removeRange([
+                  Math.min(def.node.range[0], comma.range[0]),
+                  Math.max(def.node.range[1], comma.range[1])
+                ]);
+              }
+            };
+          }
+          case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier: {
+            const importDecl = def.node.parent;
+            return {
+              messageId: "removeUnusedImportDeclaration",
+              fix: (fixer) => fixer.remove(importDecl)
+            };
+          }
+        }
+      }
       function defToVariableType(def) {
         if (options.destructuredArrayIgnorePattern && def.name.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
-          return "array-destructure";
+          return { type: VariableType.ArrayDestructure, def };
         }
         switch (def.type) {
           case scope_manager_1.DefinitionType.CatchClause:
-            return "catch-clause";
+            return { type: VariableType.CatchClause, def };
+          case scope_manager_1.DefinitionType.ClassName:
+            return { type: VariableType.ClassName, def };
+          case scope_manager_1.DefinitionType.FunctionName:
+            return { type: VariableType.FunctionName, def };
+          case scope_manager_1.DefinitionType.ImplicitGlobalVariable:
+            return { type: VariableType.ImplicitGlobalVariable, def };
+          case scope_manager_1.DefinitionType.ImportBinding:
+            return { type: VariableType.ImportBinding, def };
           case scope_manager_1.DefinitionType.Parameter:
-            return "parameter";
-          default:
-            return "variable";
+            return { type: VariableType.Parameter, def };
+          case scope_manager_1.DefinitionType.TSEnumName:
+            return { type: VariableType.TSEnumName, def };
+          case scope_manager_1.DefinitionType.TSEnumMember:
+            return { type: VariableType.TSEnumMember, def };
+          case scope_manager_1.DefinitionType.TSModuleName:
+            return { type: VariableType.TSModuleName, def };
+          case scope_manager_1.DefinitionType.Type:
+            return { type: VariableType.Type, def };
+          case scope_manager_1.DefinitionType.Variable:
+            return { type: VariableType.Variable, def };
         }
       }
       function getVariableDescription(variableType) {
         switch (variableType) {
-          case "array-destructure":
+          case VariableType.ArrayDestructure:
             return {
               pattern: options.destructuredArrayIgnorePattern?.toString(),
               variableDescription: "elements of array destructuring"
             };
-          case "catch-clause":
+          case VariableType.CatchClause:
             return {
               pattern: options.caughtErrorsIgnorePattern?.toString(),
               variableDescription: "caught errors"
             };
-          case "parameter":
+          case VariableType.Parameter:
             return {
               pattern: options.argsIgnorePattern?.toString(),
               variableDescription: "args"
             };
-          case "variable":
+          default:
             return {
               pattern: options.varsIgnorePattern?.toString(),
               variableDescription: "vars"
@@ -309493,7 +310024,7 @@ var require_no_unused_vars2 = __commonJS((exports) => {
         const def = unusedVar.defs.at(0);
         let additionalMessageData = "";
         if (def) {
-          const { pattern, variableDescription } = getVariableDescription(defToVariableType(def));
+          const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type);
           if (pattern && variableDescription) {
             additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
           }
@@ -309508,7 +310039,7 @@ var require_no_unused_vars2 = __commonJS((exports) => {
         const def = unusedVar.defs.at(0);
         let additionalMessageData = "";
         if (def) {
-          const { pattern, variableDescription } = getVariableDescription(defToVariableType(def));
+          const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type);
           if (pattern && variableDescription) {
             additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
           }
@@ -309574,10 +310105,9 @@ var require_no_unused_vars2 = __commonJS((exports) => {
           const refUsedInArrayPatterns = variable.references.some((ref) => ref.identifier.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern);
           if ((def.name.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern || refUsedInArrayPatterns) && def.name.type === utils_1.AST_NODE_TYPES.Identifier && options.destructuredArrayIgnorePattern?.test(def.name.name)) {
             if (options.reportUsedIgnorePattern && used) {
-              context.report({
-                node: def.name,
+              report(variable, {
                 messageId: "usedIgnoredVar",
-                data: getUsedIgnoredMessageData(variable, "array-destructure")
+                data: getUsedIgnoredMessageData(variable, VariableType.ArrayDestructure)
               });
             }
             continue;
@@ -309594,10 +310124,9 @@ var require_no_unused_vars2 = __commonJS((exports) => {
             }
             if (def.name.type === utils_1.AST_NODE_TYPES.Identifier && options.caughtErrorsIgnorePattern?.test(def.name.name)) {
               if (options.reportUsedIgnorePattern && used) {
-                context.report({
-                  node: def.name,
+                report(variable, {
                   messageId: "usedIgnoredVar",
-                  data: getUsedIgnoredMessageData(variable, "catch-clause")
+                  data: getUsedIgnoredMessageData(variable, VariableType.CatchClause)
                 });
               }
               continue;
@@ -309608,10 +310137,9 @@ var require_no_unused_vars2 = __commonJS((exports) => {
             }
             if (def.name.type === utils_1.AST_NODE_TYPES.Identifier && options.argsIgnorePattern?.test(def.name.name)) {
               if (options.reportUsedIgnorePattern && used) {
-                context.report({
-                  node: def.name,
+                report(variable, {
                   messageId: "usedIgnoredVar",
-                  data: getUsedIgnoredMessageData(variable, "parameter")
+                  data: getUsedIgnoredMessageData(variable, VariableType.Parameter)
                 });
               }
               continue;
@@ -309621,10 +310149,9 @@ var require_no_unused_vars2 = __commonJS((exports) => {
             }
           } else if (def.name.type === utils_1.AST_NODE_TYPES.Identifier && options.varsIgnorePattern?.test(def.name.name)) {
             if (options.reportUsedIgnorePattern && used && def.type !== utils_1.TSESLint.Scope.DefinitionType.TSEnumMember) {
-              context.report({
-                node: def.name,
+              report(variable, {
                 messageId: "usedIgnoredVar",
-                data: getUsedIgnoredMessageData(variable, "variable")
+                data: getUsedIgnoredMessageData(variable, VariableType.Variable)
               });
             }
             continue;
@@ -309684,24 +310211,12 @@ var require_no_unused_vars2 = __commonJS((exports) => {
           for (const unusedVar of unusedVars) {
             if (unusedVar.defs.length > 0) {
               const usedOnlyAsType = unusedVar.references.some((ref) => (0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier));
+              const messageId = usedOnlyAsType ? "usedOnlyAsType" : "unusedVar";
               const isImportUsedOnlyAsType = usedOnlyAsType && unusedVar.defs.some((def) => def.type === scope_manager_1.DefinitionType.ImportBinding);
               if (isImportUsedOnlyAsType) {
                 continue;
               }
-              const writeReferences = unusedVar.references.filter((ref) => ref.isWrite() && ref.from.variableScope === unusedVar.scope.variableScope);
-              const id = writeReferences.length ? writeReferences[writeReferences.length - 1].identifier : unusedVar.identifiers[0];
-              const messageId = usedOnlyAsType ? "usedOnlyAsType" : "unusedVar";
-              const { start } = id.loc;
-              const idLength = id.name.length;
-              const loc = {
-                start,
-                end: {
-                  column: start.column + idLength,
-                  line: start.line
-                }
-              };
-              context.report({
-                loc,
+              report(unusedVar, {
                 messageId,
                 data: unusedVar.references.some((ref) => ref.isWrite()) ? getAssignedMessageData(unusedVar) : getDefinedMessageData(unusedVar)
               });
@@ -310170,13 +310685,6 @@ var require_no_useless_default_assignment = __commonJS((exports) => {
         }
         return tsutils.unionConstituents(type).some((part) => (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
       }
-      function getPropertyType(objectType, propertyName) {
-        const symbol = objectType.getProperty(propertyName);
-        if (!symbol) {
-          return null;
-        }
-        return checker.getTypeOfSymbol(symbol);
-      }
       function getArrayElementType(arrayType, elementIndex) {
         if (checker.isTupleType(arrayType)) {
           const tupleArgs = checker.getTypeArguments(arrayType);
@@ -310214,6 +310722,9 @@ var require_no_useless_default_assignment = __commonJS((exports) => {
               const params = signatures[0].getParameters();
               if (paramIndex < params.length) {
                 const paramSymbol = params[paramIndex];
+                if (paramSymbol.valueDeclaration && ts.isParameter(paramSymbol.valueDeclaration) && paramSymbol.valueDeclaration.dotDotDotToken != null) {
+                  return;
+                }
                 if ((paramSymbol.flags & ts.SymbolFlags.Optional) === 0) {
                   const paramType = checker.getTypeOfSymbol(paramSymbol);
                   if (!canBeUndefined(paramType)) {
@@ -310262,7 +310773,24 @@ var require_no_useless_default_assignment = __commonJS((exports) => {
         if (!propertyName) {
           return null;
         }
-        return getPropertyType(sourceType, propertyName);
+        const symbol = sourceType.getProperty(propertyName);
+        if (!symbol) {
+          return null;
+        }
+        if (symbol.flags & ts.SymbolFlags.Optional && hasConditionalInitializer(objectPattern)) {
+          return null;
+        }
+        return checker.getTypeOfSymbol(symbol);
+      }
+      function hasConditionalInitializer(node) {
+        const parent = node.parent;
+        if (!parent) {
+          return false;
+        }
+        if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && parent.init) {
+          return parent.init.type === utils_1.AST_NODE_TYPES.ConditionalExpression || parent.init.type === utils_1.AST_NODE_TYPES.LogicalExpression;
+        }
+        return hasConditionalInitializer(parent);
       }
       function getSourceTypeForPattern(pattern) {
         const parent = (0, util_1.nullThrows)(pattern.parent, util_1.NullThrowsReasons.MissingParent);
@@ -310284,12 +310812,11 @@ var require_no_useless_default_assignment = __commonJS((exports) => {
           return getTypeOfProperty(parent);
         }
         if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
-          const arrayPattern = parent;
-          const arrayType = getSourceTypeForPattern(arrayPattern);
+          const arrayType = getSourceTypeForPattern(parent);
           if (!arrayType) {
             return null;
           }
-          const elementIndex = arrayPattern.elements.indexOf(pattern);
+          const elementIndex = parent.elements.indexOf(pattern);
           return getArrayElementType(arrayType, elementIndex);
         }
         return null;
@@ -317564,6 +318091,272 @@ var require_strict_boolean_expressions = __commonJS((exports) => {
   }
 });
 
+// ../../node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-void-return.js
+var require_strict_void_return = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k = ownKeys(mod), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod, k[i]);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var utils_1 = require_dist10();
+  var tsutils = __importStar(require_lib4());
+  var ts = __importStar(require_typescript());
+  var util = __importStar(require_util3());
+  exports.default = util.createRule({
+    name: "strict-void-return",
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Disallow passing a value-returning function in a position accepting a void function",
+        requiresTypeChecking: true
+      },
+      messages: {
+        asyncFunc: "Async function used in a context where a void function is expected.",
+        nonVoidFunc: "Value-returning function used in a context where a void function is expected.",
+        nonVoidReturn: "Value returned in a context where a void return is expected."
+      },
+      schema: [
+        {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            allowReturnAny: {
+              type: "boolean",
+              description: "Whether to allow functions returning `any` to be used in place expecting a `void` function."
+            }
+          }
+        }
+      ]
+    },
+    defaultOptions: [
+      {
+        allowReturnAny: false
+      }
+    ],
+    create(context, [options]) {
+      const sourceCode = context.sourceCode;
+      const parserServices = util.getParserServices(context);
+      const checker = parserServices.program.getTypeChecker();
+      return {
+        ArrayExpression: (node) => {
+          for (const elemNode of node.elements) {
+            if (elemNode != null && elemNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+              checkExpressionNode(elemNode);
+            }
+          }
+        },
+        ArrowFunctionExpression: (node) => {
+          if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+            checkExpressionNode(node.body);
+          }
+        },
+        AssignmentExpression: (node) => {
+          checkExpressionNode(node.right);
+        },
+        "CallExpression, NewExpression": checkFunctionCallNode,
+        JSXAttribute: (node) => {
+          if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type !== utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
+            checkExpressionNode(node.value.expression);
+          }
+        },
+        MethodDefinition: checkClassMethodNode,
+        ObjectExpression: (node) => {
+          for (const propNode of node.properties) {
+            if (propNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+              checkObjectPropertyNode(propNode);
+            }
+          }
+        },
+        PropertyDefinition: checkClassPropertyNode,
+        ReturnStatement: (node) => {
+          if (node.argument != null) {
+            checkExpressionNode(node.argument);
+          }
+        },
+        VariableDeclarator: (node) => {
+          if (node.init != null) {
+            checkExpressionNode(node.init);
+          }
+        }
+      };
+      function isVoidReturningFunctionType(type) {
+        const returnTypes = tsutils.getCallSignaturesOfType(type).flatMap((signature) => tsutils.unionConstituents(signature.getReturnType()));
+        return returnTypes.length > 0 && returnTypes.every((type2) => tsutils.isTypeFlagSet(type2, ts.TypeFlags.Void));
+      }
+      function checkExpressionNode(node) {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const expectedType = checker.getContextualType(tsNode);
+        if (expectedType != null && isVoidReturningFunctionType(expectedType)) {
+          reportIfNonVoidFunction(node);
+          return true;
+        }
+        return false;
+      }
+      function checkFunctionCallNode(callNode) {
+        const callTsNode = parserServices.esTreeNodeToTSNodeMap.get(callNode);
+        const funcType = checker.getTypeAtLocation(callTsNode.expression);
+        const funcSignatures = tsutils.unionConstituents(funcType).flatMap((type) => ts.isCallExpression(callTsNode) ? type.getCallSignatures() : type.getConstructSignatures());
+        for (const [argIdx, argNode] of callNode.arguments.entries()) {
+          if (argNode.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+            continue;
+          }
+          if (checkExpressionNode(argNode)) {
+            continue;
+          }
+          const argExpectedReturnTypes = funcSignatures.map((s) => s.parameters[argIdx]).filter(Boolean).map((param) => checker.getTypeOfSymbolAtLocation(param, callTsNode.expression)).flatMap((paramType) => tsutils.unionConstituents(paramType)).flatMap((paramType) => paramType.getCallSignatures()).map((paramSignature) => paramSignature.getReturnType());
+          if (argExpectedReturnTypes.some((type) => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)) && argExpectedReturnTypes.every((type) => tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Any | ts.TypeFlags.Never))) {
+            reportIfNonVoidFunction(argNode);
+          }
+        }
+      }
+      function checkObjectPropertyNode(propNode) {
+        const valueNode = propNode.value;
+        const propTsNode = parserServices.esTreeNodeToTSNodeMap.get(propNode);
+        if (propTsNode.kind === ts.SyntaxKind.MethodDeclaration) {
+          if (propTsNode.name.kind === ts.SyntaxKind.ComputedPropertyName) {
+            return;
+          }
+          const objTsNode = propTsNode.parent;
+          const objType = checker.getContextualType(objTsNode);
+          if (objType == null) {
+            return;
+          }
+          const propSymbol = checker.getPropertyOfType(objType, propTsNode.name.text);
+          if (propSymbol == null) {
+            return;
+          }
+          const propExpectedType = checker.getTypeOfSymbolAtLocation(propSymbol, propTsNode);
+          if (isVoidReturningFunctionType(propExpectedType)) {
+            reportIfNonVoidFunction(valueNode);
+          }
+          return;
+        }
+        checkExpressionNode(valueNode);
+      }
+      function checkClassPropertyNode(propNode) {
+        if (propNode.value == null) {
+          return;
+        }
+        for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, propNode)) {
+          if (isVoidReturningFunctionType(baseMemberType)) {
+            reportIfNonVoidFunction(propNode.value);
+            return;
+          }
+        }
+        checkExpressionNode(propNode.value);
+      }
+      function checkClassMethodNode(methodNode) {
+        if (methodNode.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+          return;
+        }
+        for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, methodNode)) {
+          if (isVoidReturningFunctionType(baseMemberType)) {
+            reportIfNonVoidFunction(methodNode.value);
+            return;
+          }
+        }
+      }
+      function reportIfNonVoidFunction(funcNode) {
+        const allowedReturnType = ts.TypeFlags.Void | ts.TypeFlags.Never | ts.TypeFlags.Undefined | (options.allowReturnAny ? ts.TypeFlags.Any : 0);
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(funcNode);
+        const actualType = checker.getApparentType(checker.getTypeAtLocation(tsNode));
+        if (tsutils.getCallSignaturesOfType(actualType).map((signature) => signature.getReturnType()).flatMap((returnType) => tsutils.unionConstituents(returnType)).every((type) => tsutils.isTypeFlagSet(type, allowedReturnType))) {
+          return;
+        }
+        if (funcNode.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression && funcNode.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+          return context.report({
+            node: funcNode,
+            messageId: `nonVoidFunc`
+          });
+        }
+        if (funcNode.generator) {
+          return context.report({
+            loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+            messageId: `nonVoidFunc`
+          });
+        }
+        if (funcNode.async) {
+          return context.report({
+            loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+            messageId: `asyncFunc`
+          });
+        }
+        if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+          return context.report({
+            node: funcNode.body,
+            messageId: `nonVoidReturn`
+          });
+        }
+        if (funcNode.returnType != null) {
+          const typeAnnotationNode = funcNode.returnType.typeAnnotation;
+          if (typeAnnotationNode.type !== utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+            return context.report({
+              node: typeAnnotationNode,
+              messageId: `nonVoidFunc`
+            });
+          }
+        }
+        for (const statement of util.walkStatements(funcNode.body.body)) {
+          if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement || statement.argument == null) {
+            continue;
+          }
+          const returnType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(statement.argument));
+          if (tsutils.isTypeFlagSet(returnType, allowedReturnType)) {
+            continue;
+          }
+          const returnKeyword = util.nullThrows(sourceCode.getFirstToken(statement, {
+            filter: (token) => token.value === "return"
+          }), util.NullThrowsReasons.MissingToken("return keyword", statement.type));
+          context.report({
+            node: returnKeyword,
+            messageId: `nonVoidReturn`
+          });
+        }
+      }
+    }
+  });
+});
+
 // ../../node_modules/@typescript-eslint/eslint-plugin/dist/rules/switch-exhaustiveness-check.js
 var require_switch_exhaustiveness_check = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
@@ -319187,6 +319980,7 @@ var require_rules4 = __commonJS((exports, module) => {
   var return_await_1 = __importDefault(require_return_await());
   var sort_type_constituents_1 = __importDefault(require_sort_type_constituents());
   var strict_boolean_expressions_1 = __importDefault(require_strict_boolean_expressions());
+  var strict_void_return_1 = __importDefault(require_strict_void_return());
   var switch_exhaustiveness_check_1 = __importDefault(require_switch_exhaustiveness_check());
   var triple_slash_reference_1 = __importDefault(require_triple_slash_reference());
   var typedef_1 = __importDefault(require_typedef());
@@ -319321,6 +320115,7 @@ var require_rules4 = __commonJS((exports, module) => {
     "return-await": return_await_1.default,
     "sort-type-constituents": sort_type_constituents_1.default,
     "strict-boolean-expressions": strict_boolean_expressions_1.default,
+    "strict-void-return": strict_void_return_1.default,
     "switch-exhaustiveness-check": switch_exhaustiveness_check_1.default,
     "triple-slash-reference": triple_slash_reference_1.default,
     typedef: typedef_1.default,
@@ -319335,7 +320130,7 @@ var require_rules4 = __commonJS((exports, module) => {
 var require_package7 = __commonJS((exports, module) => {
   module.exports = {
     name: "@typescript-eslint/eslint-plugin",
-    version: "8.51.0",
+    version: "8.53.0",
     description: "TypeScript plugin for ESLint",
     files: [
       "dist",
@@ -319393,39 +320188,39 @@ var require_package7 = __commonJS((exports, module) => {
       typecheck: "yarn run -BT nx typecheck"
     },
     dependencies: {
-      "@eslint-community/regexpp": "^4.10.0",
-      "@typescript-eslint/scope-manager": "8.51.0",
-      "@typescript-eslint/type-utils": "8.51.0",
-      "@typescript-eslint/utils": "8.51.0",
-      "@typescript-eslint/visitor-keys": "8.51.0",
-      ignore: "^7.0.0",
+      "@eslint-community/regexpp": "^4.12.2",
+      "@typescript-eslint/scope-manager": "8.53.0",
+      "@typescript-eslint/type-utils": "8.53.0",
+      "@typescript-eslint/utils": "8.53.0",
+      "@typescript-eslint/visitor-keys": "8.53.0",
+      ignore: "^7.0.5",
       "natural-compare": "^1.4.0",
-      "ts-api-utils": "^2.2.0"
+      "ts-api-utils": "^2.4.0"
     },
     devDependencies: {
-      "@types/mdast": "^4.0.3",
+      "@types/mdast": "^4.0.4",
       "@types/natural-compare": "*",
-      "@typescript-eslint/rule-schema-to-typescript-types": "8.51.0",
-      "@typescript-eslint/rule-tester": "8.51.0",
-      "@vitest/coverage-v8": "^3.1.3",
+      "@typescript-eslint/rule-schema-to-typescript-types": "8.53.0",
+      "@typescript-eslint/rule-tester": "8.53.0",
+      "@vitest/coverage-v8": "^3.2.4",
       ajv: "^6.12.6",
       eslint: "*",
       "json-schema": "*",
-      "markdown-table": "^3.0.3",
-      marked: "^15.0.0",
-      "mdast-util-from-markdown": "^2.0.0",
+      "markdown-table": "^3.0.4",
+      marked: "^15.0.12",
+      "mdast-util-from-markdown": "^2.0.2",
       "mdast-util-mdx": "^3.0.0",
       "micromark-extension-mdxjs": "^3.0.0",
-      prettier: "3.7.2",
+      prettier: "3.7.4",
       rimraf: "*",
-      "title-case": "^4.0.0",
+      "title-case": "^4.3.2",
       tsx: "*",
       typescript: "*",
       "unist-util-visit": "^5.0.0",
-      vitest: "^3.1.3"
+      vitest: "^3.2.4"
     },
     peerDependencies: {
-      "@typescript-eslint/parser": "^8.51.0",
+      "@typescript-eslint/parser": "^8.53.0",
       eslint: "^8.57.0 || ^9.0.0",
       typescript: ">=4.8.4 <6.0.0"
     },