@codacy/tools-checkstyle-13 0.22.0

package/dist/index.js

@@ -0,0 +1,4748 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_tooling2 = require("@codacy/tooling");
+
+// src/adapter.ts
+var import_tooling = require("@codacy/tooling");
+var import_fast_xml_parser = require("fast-xml-parser");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+
+// src/patterns.json
+var patterns_default = [
+  {
+    id: "Checkstyle_AbbreviationAsWordInName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Abbreviation Length in Identifier Names",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowedAbbreviationLength",
+        default: "3",
+        description: "Indicate the number of consecutive capital letters allowed in targeted identifiers (abbreviations in the classes, interfaces, variables and methods names, ... )."
+      },
+      {
+        name: "allowedAbbreviations",
+        default: "",
+        description: "Specify abbreviations that must be skipped for checking."
+      },
+      {
+        name: "ignoreFinal",
+        default: "true",
+        description: "Allow to skip variables with final modifier."
+      },
+      {
+        name: "ignoreOverriddenMethods",
+        default: "true",
+        description: "Allow to ignore methods tagged with @Override annotation (that usually mean inherited name)."
+      },
+      {
+        name: "ignoreStatic",
+        default: "true",
+        description: "Allow to skip variables with static modifier."
+      },
+      {
+        name: "ignoreStaticFinal",
+        default: "true",
+        description: "Allow to skip variables with both static and final modifiers."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, PARAMETER_DEF, VARIABLE_DEF, METHOD_DEF, PATTERN_VARIABLE_DEF, RECORD_DEF, RECORD_COMPONENT_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AbstractClassName",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Abstract Class Naming Convention",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^Abstract.+$",
+        description: "Specify valid identifiers."
+      },
+      {
+        name: "ignoreModifier",
+        default: "false",
+        description: "Control whether to ignore checking for the abstract modifier on classes that match the name."
+      },
+      {
+        name: "ignoreName",
+        default: "false",
+        description: "Control whether to ignore checking the name. Realistically only useful if using the check to identify that match name and do not have the abstract modifier."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AnnotatedDeclarationVisibility",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce annotated declaration visibility",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "annotations",
+        default: "com.google.common.annotations.VisibleForTesting",
+        description: "Setter for annotation canonical names."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, RECORD_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF, ANNOTATION_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "visibility",
+        default: "protected, package",
+        description: "Setter for allowed visibility modifiers. Allowed values: public, protected, package, private."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AnnotationLocation",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Annotation Location",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowSamelineMultipleAnnotations",
+        default: "false",
+        description: "Allow annotation(s) to be located on the same line as target element."
+      },
+      {
+        name: "allowSamelineParameterizedAnnotation",
+        default: "false",
+        description: "Allow one and only parameterized annotation to be located on the same line as target element."
+      },
+      {
+        name: "allowSamelineSingleParameterlessAnnotation",
+        default: "true",
+        description: "Allow single parameterless annotation to be located on the same line as target element."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, PACKAGE_DEF, ENUM_CONSTANT_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF, RECORD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AnnotationOnSameLine",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Annotation On Same Line",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF, RECORD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AnnotationUseStyle",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Annotation Element Style",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "closingParens",
+        default: "never",
+        description: "Define the policy for ending parenthesis."
+      },
+      {
+        name: "elementStyle",
+        default: "compact_no_array",
+        description: "Define the annotation element styles."
+      },
+      {
+        name: "trailingArrayComma",
+        default: "never",
+        description: "Define the policy for trailing comma in arrays."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AnonInnerLength",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Long Anonymous Inner Classes",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "20",
+        description: "Specify the maximum number of lines allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ArrayTrailingComma",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Array Trailing Comma",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "alwaysDemandTrailingComma",
+        default: "false",
+        description: "Control whether to always check for a trailing comma, even when an array is inline."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ArrayTypeStyle",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Java Style Array Type Declarations",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "javaStyle",
+        default: "true",
+        description: "Control whether to enforce Java style (true) or C style (false)."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AtclauseOrder",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc At-Clause Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tagOrder",
+        default: "@author, @version, @param, @return, @throws, @exception, @see, @since, @serial, @serialField, @serialData, @deprecated",
+        description: "Specify the order by tags."
+      },
+      {
+        name: "target",
+        default: "CLASS_DEF, COMPACT_CTOR_DEF, CTOR_DEF, ENUM_DEF, INTERFACE_DEF, METHOD_DEF, RECORD_DEF, VARIABLE_DEF",
+        description: "Specify block tags targeted."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AvoidDoubleBraceInitialization",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Double Brace Initialization",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_AvoidEscapedUnicodeCharacters",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Using Escaped Unicode Characters",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowByTailComment",
+        default: "false",
+        description: "Allow use escapes if trail comment is present."
+      },
+      {
+        name: "allowEscapesForControlCharacters",
+        default: "false",
+        description: "Allow use escapes for non-printable, control characters."
+      },
+      {
+        name: "allowIfAllCharactersEscaped",
+        default: "false",
+        description: "Allow if all characters in literal are escaped."
+      },
+      {
+        name: "allowNonPrintableEscapes",
+        default: "false",
+        description: "Allow use escapes for non-printable, whitespace characters."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AvoidInlineConditionals",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Inline Conditionals",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_AvoidNestedBlocks",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Nested Blocks",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowInSwitchCase",
+        default: "false",
+        description: "Allow nested blocks if they are the only child of a switch case."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AvoidNoArgumentSuperConstructorCall",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid No-Argument Superclass Constructor Call",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_AvoidStarImport",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Star Imports",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowClassImports",
+        default: "false",
+        description: "Control whether to allow starred class imports like import java.util.*;."
+      },
+      {
+        name: "allowStaticMemberImports",
+        default: "false",
+        description: "Control whether to allow starred static member imports like import static org.junit.Assert.*;."
+      },
+      {
+        name: "excludes",
+        default: "",
+        description: "Specify packages where starred class imports are allowed and classes where starred static member imports are allowed."
+      },
+      {
+        name: "maxAllowedStarImports",
+        default: "0",
+        description: "Control how many star imports are allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_AvoidStaticImport",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Static Import",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "excludes",
+        default: "",
+        description: "excludes"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_BooleanExpressionComplexity",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Restrict Boolean Expression Complexity",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "3",
+        description: "Specify the maximum number of boolean operations allowed in one expression."
+      },
+      {
+        name: "tokens",
+        default: "LAND, BAND, LOR, BOR, BXOR",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_CatchParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Catch Parameter Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^(e|t|ex|[a-z][a-z][a-zA-Z]+|_)$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ClassDataAbstractionCoupling",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Class Data Abstraction Coupling Limit",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "excludeClassesRegexps",
+        default: "^$",
+        description: "Specify user-configured regular expressions to ignore classes."
+      },
+      {
+        name: "excludedClasses",
+        default: "ArrayIndexOutOfBoundsException, ArrayList, Boolean, Byte, Character, Class, Collection, Deprecated, Deque, Double, DoubleStream, EnumSet, Exception, Float, FunctionalInterface, HashMap, HashSet, IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException, IntStream, Integer, LinkedHashMap, LinkedHashSet, LinkedList, List, Long, LongStream, Map, NullPointerException, Object, Optional, OptionalDouble, OptionalInt, OptionalLong, Override, Queue, RuntimeException, SafeVarargs, SecurityException, Set, Short, SortedMap, SortedSet, Stream, String, StringBuffer, StringBuilder, SuppressWarnings, Throwable, TreeMap, TreeSet, UnsupportedOperationException, Void, boolean, byte, char, double, float, int, long, short, var, void",
+        description: "Specify user-configured class names to ignore."
+      },
+      {
+        name: "excludedPackages",
+        default: "",
+        description: "Specify user-configured packages to ignore."
+      },
+      {
+        name: "max",
+        default: "7",
+        description: "Specify the maximum threshold allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ClassFanOutComplexity",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Class Fan-Out Complexity Limits",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "excludeClassesRegexps",
+        default: "^$",
+        description: "Specify user-configured regular expressions to ignore classes."
+      },
+      {
+        name: "excludedClasses",
+        default: "ArrayIndexOutOfBoundsException, ArrayList, Boolean, Byte, Character, Class, Collection, Deprecated, Deque, Double, DoubleStream, EnumSet, Exception, Float, FunctionalInterface, HashMap, HashSet, IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException, IntStream, Integer, LinkedHashMap, LinkedHashSet, LinkedList, List, Long, LongStream, Map, NullPointerException, Object, Optional, OptionalDouble, OptionalInt, OptionalLong, Override, Queue, RuntimeException, SafeVarargs, SecurityException, Set, Short, SortedMap, SortedSet, Stream, String, StringBuffer, StringBuilder, SuppressWarnings, Throwable, TreeMap, TreeSet, UnsupportedOperationException, Void, boolean, byte, char, double, float, int, long, short, var, void",
+        description: "Specify user-configured class names to ignore."
+      },
+      {
+        name: "excludedPackages",
+        default: "",
+        description: "Specify user-configured packages to ignore."
+      },
+      {
+        name: "max",
+        default: "20",
+        description: "Specify the maximum threshold allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ClassMemberImpliedModifier",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "EnforceExplicitStaticModifierOnNestedTypes",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateImpliedStaticOnNestedEnum",
+        default: "true",
+        description: "Control whether to enforce that static is explicitly coded on nested enums in classes and records."
+      },
+      {
+        name: "violateImpliedStaticOnNestedInterface",
+        default: "true",
+        description: "Control whether to enforce that static is explicitly coded on nested interfaces in classes and records."
+      },
+      {
+        name: "violateImpliedStaticOnNestedRecord",
+        default: "true",
+        description: "Control whether to enforce that static is explicitly coded on nested records in classes and records."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ClassTypeParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Class Type Parameter Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[A-Z]$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_CommentsIndentation",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Comments Indentation",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "SINGLE_LINE_COMMENT, BLOCK_COMMENT_BEGIN",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ConstantName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Constant Naming Conventions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "applyToPackage",
+        default: "true",
+        description: "Control if check should apply to package-private members."
+      },
+      {
+        name: "applyToPrivate",
+        default: "true",
+        description: "Control if check should apply to private members."
+      },
+      {
+        name: "applyToProtected",
+        default: "true",
+        description: "Control if check should apply to protected members."
+      },
+      {
+        name: "applyToPublic",
+        default: "true",
+        description: "Control if check should apply to public members."
+      },
+      {
+        name: "format",
+        default: "^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ConstructorsDeclarationGrouping",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Constructors Declaration Grouping",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "orderByIncreasingParameterCount",
+        default: "false",
+        description: "Control whether to enforce order by increasing parameter count (arity) or not."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_CovariantEquals",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Covariant Equals Method Without Overriding equals(Object)",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_CustomImportOrder",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Custom Import Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "customImportOrderRules",
+        default: "",
+        description: "Specify ordered list of import groups."
+      },
+      {
+        name: "separateLineBetweenGroups",
+        default: "true",
+        description: "Force empty line separator between import groups."
+      },
+      {
+        name: "sortImportsInGroupAlphabetically",
+        default: "false",
+        description: "Force grouping alphabetically, in ASCII sort order."
+      },
+      {
+        name: "specialImportsRegExp",
+        default: "^$",
+        description: "Specify RegExp for SPECIAL_IMPORTS group imports."
+      },
+      {
+        name: "standardPackageRegExp",
+        default: "^(java|javax)\\.",
+        description: "Specify RegExp for STANDARD_JAVA_PACKAGE group imports."
+      },
+      {
+        name: "thirdPartyPackageRegExp",
+        default: ".*",
+        description: "Specify RegExp for THIRD_PARTY_PACKAGE group imports."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_CyclomaticComplexity",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Cyclomatic Complexity Limit",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "10",
+        description: "Specify the maximum threshold allowed."
+      },
+      {
+        name: "switchBlockAsSingleDecisionPoint",
+        default: "false",
+        description: "Control whether to treat the whole switch block as a single decision point."
+      },
+      {
+        name: "tokens",
+        default: "LITERAL_WHILE, LITERAL_DO, LITERAL_FOR, LITERAL_IF, LITERAL_SWITCH, LITERAL_CASE, LITERAL_CATCH, QUESTION, LAND, LOR, LITERAL_WHEN",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_DeclarationOrder",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Declaration Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreConstructors",
+        default: "false",
+        description: "Control whether to ignore constructors."
+      },
+      {
+        name: "ignoreModifiers",
+        default: "false",
+        description: "Control whether to ignore modifiers (fields, ...)."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_DefaultComesLast",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Default Case Last in Switch Statements",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "skipIfLastAndSharedWithCase",
+        default: "false",
+        description: "Control whether to allow default along with case if they are not last."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_DescendantToken",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Restrictions on Descendant Tokens",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "limitedTokens",
+        default: "",
+        description: "Specify set of tokens with limited occurrences as descendants."
+      },
+      {
+        name: "maximumDepth",
+        default: "2147483647",
+        description: "Specify the maximum depth for descendant counts."
+      },
+      {
+        name: "maximumMessage",
+        default: "null",
+        description: "Define the violation message when the maximum count is exceeded."
+      },
+      {
+        name: "maximumNumber",
+        default: "2147483647",
+        description: "Specify a maximum count for descendants."
+      },
+      {
+        name: "minimumDepth",
+        default: "0",
+        description: "Specify the minimum depth for descendant counts."
+      },
+      {
+        name: "minimumMessage",
+        default: "null",
+        description: "Define the violation message when the minimum count is not reached."
+      },
+      {
+        name: "minimumNumber",
+        default: "0",
+        description: "Specify a minimum count for descendants."
+      },
+      {
+        name: "sumTokenCounts",
+        default: "false",
+        description: "Control whether the number of tokens found should be calculated from the sum of the individual token counts."
+      },
+      {
+        name: "tokens",
+        default: "null",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_DesignForExtension",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Detect Classes Designed for Extension",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoredAnnotations",
+        default: "After, AfterClass, Before, BeforeClass, Test",
+        description: "Specify annotations which allow the check to skip the method from validation."
+      },
+      {
+        name: "requiredJavadocPhrase",
+        default: ".*",
+        description: "Specify the comment text pattern which qualifies a method as designed for extension. Supports multi-line regex."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyBlock",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Empty Blocks",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "statement",
+        description: "Specify the policy on block contents."
+      },
+      {
+        name: "tokens",
+        default: "LITERAL_WHILE, LITERAL_TRY, LITERAL_FINALLY, LITERAL_DO, LITERAL_IF, LITERAL_ELSE, LITERAL_FOR, INSTANCE_INIT, STATIC_INIT, LITERAL_SWITCH, LITERAL_SYNCHRONIZED",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyCatchBlock",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Empty Catch Blocks",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "commentFormat",
+        default: ".*",
+        description: "Specify the RegExp for the first comment inside empty catch block. If check meets comment inside empty catch block matching specified format - empty block is suppressed. If it is multi-line comment - only its first line is analyzed."
+      },
+      {
+        name: "exceptionVariableName",
+        default: "^$",
+        description: "Specify the RegExp for the name of the variable associated with exception. If check meets variable name matching specified value - empty block is suppressed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyForInitializerPad",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Padding for Empty For Loop Initializer",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "nospace",
+        description: "Specify policy on how to pad an empty for iterator."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyForIteratorPad",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Padding on Empty For Loop Iterator",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "nospace",
+        description: "Specify policy on how to pad an empty for iterator."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyLineSeparator",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Empty Line Separators",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowMultipleEmptyLines",
+        default: "true",
+        description: "Allow multiple empty lines between class members."
+      },
+      {
+        name: "allowMultipleEmptyLinesInsideClassMembers",
+        default: "true",
+        description: "Allow multiple empty lines inside class members."
+      },
+      {
+        name: "allowNoEmptyLineBetweenFields",
+        default: "false",
+        description: "Allow no empty line between fields."
+      },
+      {
+        name: "tokens",
+        default: "PACKAGE_DEF, IMPORT, STATIC_IMPORT, MODULE_IMPORT, CLASS_DEF, INTERFACE_DEF, ENUM_DEF, STATIC_INIT, INSTANCE_INIT, METHOD_DEF, CTOR_DEF, VARIABLE_DEF, RECORD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EmptyStatement",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Empty Statements",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_EqualsAvoidNull",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Enforce String Literal on Left Side of equals() to Avoid NullPointerException",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreEqualsIgnoreCase",
+        default: "false",
+        description: "Control whether to ignore String.equalsIgnoreCase(String) invocations."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_EqualsHashCode",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Enforce Overriding Both equals() and hashCode()",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_ExecutableStatementCount",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Executable Statement Count Limit",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "30",
+        description: "Specify the maximum threshold allowed."
+      },
+      {
+        name: "tokens",
+        default: "CTOR_DEF, METHOD_DEF, INSTANCE_INIT, STATIC_INIT, COMPACT_CTOR_DEF, LAMBDA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ExplicitInitialization",
+    category: "Performance",
+    severityLevel: "Info",
+    title: "Avoid Explicit Initialization to Default Values",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "onlyObjectReferences",
+        default: "false",
+        description: "Control whether only explicit initializations made to null for objects should be checked."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_FallThrough",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Fall-Through in Switch Statements",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "checkLastCaseGroup",
+        default: "false",
+        description: "Control whether the last case group must be checked."
+      },
+      {
+        name: "reliefPattern",
+        default: "falls?[ -]?thr(u|ough)",
+        description: "Define the RegExp to match the relief comment that suppresses the warning about a fall through."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_FileLength",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Excessive File Length",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "max",
+        default: "2000",
+        description: "Specify the maximum number of lines allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_FileTabCharacter",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Tab Characters in Source Code",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "eachLine",
+        default: "false",
+        description: "Control whether to report on each line containing a tab, or just the first instance."
+      },
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_FinalClass",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Final Modifier on Applicable Classes",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_FinalLocalVariable",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Final Declaration for Unchanged Local Variables",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "VARIABLE_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "validateEnhancedForLoopVariable",
+        default: "false",
+        description: "Control whether to check enhanced for-loop variable."
+      },
+      {
+        name: "validateUnnamedVariables",
+        default: "false",
+        description: "Control whether to check unnamed variables."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_FinalParameters",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "EnforceFinalParameters",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignorePrimitiveTypes",
+        default: "false",
+        description: "Ignore primitive types as parameters."
+      },
+      {
+        name: "ignoreUnnamedParameters",
+        default: "true",
+        description: "Ignore unnamed parameters."
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_GenericWhitespace",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Correct Whitespace Around Generic Angle Brackets",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_GoogleNonConstantFieldName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Google non-constant field naming",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_Header",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Source File Header",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "header",
+        default: "null",
+        description: 'Specify the required header specified inline. Individual header lines must be separated by the string "\\n"(even on platforms with a different line separator).'
+      },
+      {
+        name: "headerFile",
+        default: "null",
+        description: "Specify the name of the file containing the required header."
+      },
+      {
+        name: "ignoreLines",
+        default: "",
+        description: "Specifies the line numbers to ignore when matching lines in a content of headerFile."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_HexLiteralCase",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "EnforceHexLiteralCase",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_HiddenField",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Hidden Fields",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreAbstractMethods",
+        default: "false",
+        description: "Control whether to ignore parameters of abstract methods."
+      },
+      {
+        name: "ignoreConstructorParameter",
+        default: "false",
+        description: "Control whether to ignore constructor parameters."
+      },
+      {
+        name: "ignoreFormat",
+        default: "null",
+        description: "Define the RegExp for names of variables and parameters to ignore."
+      },
+      {
+        name: "ignoreSetter",
+        default: "false",
+        description: "Allow to ignore the parameter of a property setter method."
+      },
+      {
+        name: "setterCanReturnItsClass",
+        default: "false",
+        description: "Allow to expand the definition of a setter method to include methods that return the class' instance."
+      },
+      {
+        name: "tokens",
+        default: "VARIABLE_DEF, PARAMETER_DEF, PATTERN_VARIABLE_DEF, LAMBDA, RECORD_COMPONENT_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_HideUtilityClassConstructor",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Hide Utility Class Constructor",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreAnnotatedBy",
+        default: "",
+        description: "ignoreAnnotatedBy"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalCatch",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Catching Generic Exceptions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "illegalClassNames",
+        default: "Error, Exception, RuntimeException, Throwable, java.lang.Error, java.lang.Exception, java.lang.RuntimeException, java.lang.Throwable",
+        description: "Specify exception class names to reject."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalIdentifierName",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Illegal Identifier Names",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^(?!var$|\\S*\\$)\\S+$",
+        description: "Sets the pattern to match valid identifiers."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, PARAMETER_DEF, VARIABLE_DEF, METHOD_DEF, ENUM_CONSTANT_DEF, PATTERN_VARIABLE_DEF, RECORD_DEF, RECORD_COMPONENT_DEF, LAMBDA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalImport",
+    category: "Compatibility",
+    severityLevel: "Warning",
+    title: "Avoid Illegal Imports",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "illegalClasses",
+        default: "",
+        description: "Specify class names to reject, if regexp property is not set, checks if import equals class name. If regexp property is set, then list of class names will be interpreted as regular expressions. Note, all properties for match will be used."
+      },
+      {
+        name: "illegalModules",
+        default: "",
+        description: "Specify module names to reject, if regexp property is not set, checks if import equals module name. If regexp property is set, then list of module names will be interpreted as regular expressions. Note, all properties for match will be used."
+      },
+      {
+        name: "illegalPkgs",
+        default: "sun",
+        description: "Specify packages to reject, if regexp property is not set, checks if import is the part of package. If regexp property is set, then list of packages will be interpreted as regular expressions. Note, all properties for match will be used."
+      },
+      {
+        name: "regexp",
+        default: "false",
+        description: "Control whether the illegalPkgs, illegalClasses and illegalModules should be interpreted as regular expressions."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalInstantiation",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Avoid Illegal Instantiation - Use Factory Methods",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "classes",
+        default: "",
+        description: "Specify fully qualified class names that should not be instantiated."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalSymbol",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow illegal Unicode symbols",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "symbolCodes",
+        default: "0x2190-0x27BF, 0x1F600-0x1F64F, 0x1F680-0x1F6FF, 0x1F700-0x10FFFF",
+        description: "Specify the symbols to check for."
+      },
+      {
+        name: "tokens",
+        default: "COMMENT_CONTENT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalThrows",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Declaring Illegal Throws",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoredMethodNames",
+        default: "finalize",
+        description: "Specify names of methods to ignore."
+      },
+      {
+        name: "ignoreOverriddenMethods",
+        default: "true",
+        description: "Allow to ignore checking overridden methods (marked with Override or java.lang.Override annotation)."
+      },
+      {
+        name: "illegalClassNames",
+        default: "Error, RuntimeException, Throwable, java.lang.Error, java.lang.RuntimeException, java.lang.Throwable",
+        description: "Specify throw class names to reject."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalToken",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Illegal Tokens",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "LABELED_STAT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalTokenText",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Detect Illegal Token Text",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^$",
+        description: "Define the RegExp for illegal pattern."
+      },
+      {
+        name: "ignoreCase",
+        default: "false",
+        description: "Control whether to ignore case when matching."
+      },
+      {
+        name: "message",
+        default: "",
+        description: "Define the message which is used to notify about violations; if empty then the default message is used."
+      },
+      {
+        name: "tokens",
+        default: "null",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_IllegalType",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Usage of Illegal Types",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoredMethodNames",
+        default: "getEnvironment, getInitialContext",
+        description: "Specify methods that should not be checked."
+      },
+      {
+        name: "illegalAbstractClassNameFormat",
+        default: "^(.*[.])?Abstract.*$",
+        description: "Specify RegExp for illegal abstract class names."
+      },
+      {
+        name: "illegalClassNames",
+        default: "HashMap, HashSet, LinkedHashMap, LinkedHashSet, TreeMap, TreeSet, java.util.HashMap, java.util.HashSet, java.util.LinkedHashMap, java.util.LinkedHashSet, java.util.TreeMap, java.util.TreeSet",
+        description: "Specify classes that should not be used as types in variable declarations, return values or parameters."
+      },
+      {
+        name: "legalAbstractClassNames",
+        default: "",
+        description: "Define abstract classes that may be used as types."
+      },
+      {
+        name: "memberModifiers",
+        default: "",
+        description: "Control whether to check only methods and fields with any of the specified modifiers. This property does not affect method calls nor method references nor record components."
+      },
+      {
+        name: "tokens",
+        default: "ANNOTATION_FIELD_DEF, CLASS_DEF, INTERFACE_DEF, METHOD_CALL, METHOD_DEF, METHOD_REF, PARAMETER_DEF, VARIABLE_DEF, PATTERN_VARIABLE_DEF, RECORD_DEF, RECORD_COMPONENT_DEF, RECORD_PATTERN_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "validateAbstractClassNames",
+        default: "false",
+        description: "Control whether to validate abstract class names."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ImportControl",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Import Control",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "file",
+        default: "null",
+        description: "Specify the location of the file containing the import control configuration. It can be a regular file, URL or resource path. It will try loading the path as a URL first, then as a file, and finally as a resource."
+      },
+      {
+        name: "path",
+        default: ".*",
+        description: "Specify the regular expression of file paths to which this check should apply. Files that don't match the pattern will not be checked. The pattern will be matched against the full absolute file path."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ImportOrder",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Import Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "caseSensitive",
+        default: "true",
+        description: "Control whether string comparison should be case-sensitive or not. Case-sensitive sorting is in ASCII sort order. It affects both type imports and static imports."
+      },
+      {
+        name: "groups",
+        default: "",
+        description: "groups"
+      },
+      {
+        name: "option",
+        default: "under",
+        description: "Specify policy on the relative order between type imports and static imports."
+      },
+      {
+        name: "ordered",
+        default: "true",
+        description: "Control whether type imports within each group should be sorted. It doesn't affect sorting for static imports."
+      },
+      {
+        name: "separated",
+        default: "false",
+        description: "Control whether type import groups should be separated by, at least, one blank line or comment and aren't separated internally. It doesn't affect separations for static imports."
+      },
+      {
+        name: "separatedStaticGroups",
+        default: "false",
+        description: "separatedStaticGroups"
+      },
+      {
+        name: "sortStaticImportsAlphabetically",
+        default: "false",
+        description: "Control whether static imports located at top or bottom are sorted within the group."
+      },
+      {
+        name: "staticGroups",
+        default: "",
+        description: "staticGroups"
+      },
+      {
+        name: "useContainerOrderingForStatic",
+        default: "false",
+        description: "Control whether to use container ordering (Eclipse IDE term) for static imports or not."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_Indentation",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Correct Indentation",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "arrayInitIndent",
+        default: "4",
+        description: "Specify how far an array initialization should be indented when on next line."
+      },
+      {
+        name: "basicOffset",
+        default: "4",
+        description: "Specify how far new indentation level should be indented when on the next line."
+      },
+      {
+        name: "braceAdjustment",
+        default: "0",
+        description: "Specify how far a braces should be indented when on the next line."
+      },
+      {
+        name: "caseIndent",
+        default: "4",
+        description: "Specify how far a case label should be indented when on next line."
+      },
+      {
+        name: "forceStrictCondition",
+        default: "false",
+        description: "Force strict indent level in line wrapping case. If value is true, line wrap indent have to be same as lineWrappingIndentation parameter. If value is false, line wrap indent could be bigger on any value user would like."
+      },
+      {
+        name: "lineWrappingIndentation",
+        default: "4",
+        description: "Specify how far continuation line should be indented when line-wrapping is present."
+      },
+      {
+        name: "throwsIndent",
+        default: "4",
+        description: "Specify how far a throws clause should be indented when on next line."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_InnerAssignment",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Inner Assignments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_InnerTypeLast",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Inner Types Declared Last",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_InterfaceIsType",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Interfaces to Define Types",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowMarkerInterfaces",
+        default: "true",
+        description: "Control whether marker interfaces like Serializable are allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_InterfaceMemberImpliedModifier",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Explicit Modifiers on Interface Members",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateImpliedAbstractMethod",
+        default: "true",
+        description: "Control whether to enforce that abstract is explicitly coded on interface methods."
+      },
+      {
+        name: "violateImpliedFinalField",
+        default: "true",
+        description: "Control whether to enforce that final is explicitly coded on interface fields."
+      },
+      {
+        name: "violateImpliedPublicField",
+        default: "true",
+        description: "Control whether to enforce that public is explicitly coded on interface fields."
+      },
+      {
+        name: "violateImpliedPublicMethod",
+        default: "true",
+        description: "Control whether to enforce that public is explicitly coded on interface methods."
+      },
+      {
+        name: "violateImpliedPublicNested",
+        default: "true",
+        description: "Control whether to enforce that public is explicitly coded on interface nested types."
+      },
+      {
+        name: "violateImpliedStaticField",
+        default: "true",
+        description: "Control whether to enforce that static is explicitly coded on interface fields."
+      },
+      {
+        name: "violateImpliedStaticNested",
+        default: "true",
+        description: "Control whether to enforce that static is explicitly coded on interface nested types."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_InterfaceTypeParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Interface Type Parameter Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[A-Z]$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_InvalidJavadocPosition",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Correct Javadoc Position",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_JavadocBlockTagLocation",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "EnforceJavadocBlockTagLocation",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tags",
+        default: "author, deprecated, exception, hidden, param, provides, return, see, serial, serialData, serialField, since, throws, uses, version",
+        description: "Specify the javadoc tags to process."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocContentLocation",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Javadoc Content Location",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "location",
+        default: "second_line",
+        description: "Specify the policy on placement of the Javadoc content."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocLeadingAsteriskAlign",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Alignment of Leading Asterisks in Javadoc Comments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocMethod",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Comments on Methods and Constructors",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "accessModifiers",
+        default: "public, protected, package, private",
+        description: "Specify the access modifiers where Javadoc comments are checked."
+      },
+      {
+        name: "allowedAnnotations",
+        default: "Override",
+        description: "Specify annotations that allow missed documentation."
+      },
+      {
+        name: "allowInlineReturn",
+        default: "false",
+        description: "Control whether to allow inline return tags."
+      },
+      {
+        name: "allowMissingParamTags",
+        default: "false",
+        description: "Control whether to ignore violations when a method has parameters but does not have matching param tags in the javadoc."
+      },
+      {
+        name: "allowMissingReturnTag",
+        default: "false",
+        description: "Control whether to ignore violations when a method returns non-void type and does not have a return tag in the javadoc."
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF, ANNOTATION_FIELD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "validateThrows",
+        default: "false",
+        description: "Control whether to validate throws tags."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocMissingLeadingAsterisk",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Leading Asterisks in Javadoc",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocMissingWhitespaceAfterAsterisk",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Whitespace After Asterisk in Javadoc Comments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocPackage",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Package Comment Presence",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowLegacy",
+        default: "false",
+        description: "Allow legacy package.html file to be used."
+      },
+      {
+        name: "fileExtensions",
+        default: ".java",
+        description: "Specify the file extensions of the files to process."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocParagraph",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Paragraph Formatting",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowNewlineParagraph",
+        default: "true",
+        description: "Control whether the <p> tag should be placed immediately before the first word."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocTagContinuationIndentation",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Tag Continuation Indentation",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "offset",
+        default: "4",
+        description: "Specify how many spaces to use for new indentation level."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocType",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Comments on Type Definitions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowedAnnotations",
+        default: "Generated",
+        description: "Specify annotations that allow skipping validation at all. Only short names are allowed, e.g. Generated."
+      },
+      {
+        name: "allowMissingParamTags",
+        default: "false",
+        description: "Control whether to ignore violations when a class has type parameters but does not have matching param tags in the Javadoc."
+      },
+      {
+        name: "allowUnknownTags",
+        default: "false",
+        description: "Control whether to ignore violations when a Javadoc tag is not recognised."
+      },
+      {
+        name: "authorFormat",
+        default: "null",
+        description: "Specify the pattern for @author tag."
+      },
+      {
+        name: "excludeScope",
+        default: "null",
+        description: "Specify the visibility scope where Javadoc comments are not checked."
+      },
+      {
+        name: "scope",
+        default: "private",
+        description: "Specify the visibility scope where Javadoc comments are checked."
+      },
+      {
+        name: "tokens",
+        default: "INTERFACE_DEF, CLASS_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "versionFormat",
+        default: "null",
+        description: "Specify the pattern for @version tag."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavadocVariable",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Comment on Variables",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "accessModifiers",
+        default: "public, protected, package, private",
+        description: "accessModifiers"
+      },
+      {
+        name: "excludeScope",
+        default: "null",
+        description: "Specify the visibility scope where Javadoc comments are not checked."
+      },
+      {
+        name: "ignoreNamePattern",
+        default: "null",
+        description: "Specify the regexp to define variable names to ignore."
+      },
+      {
+        name: "scope",
+        default: "private",
+        description: "Specify the visibility scope where Javadoc comments are checked."
+      },
+      {
+        name: "tokens",
+        default: "ENUM_CONSTANT_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_JavaNCSS",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce JavaNCSS Complexity Limits",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "classMaximum",
+        default: "1500",
+        description: "Specify the maximum allowed number of non commenting lines in a class."
+      },
+      {
+        name: "fileMaximum",
+        default: "2000",
+        description: "Specify the maximum allowed number of non commenting lines in a file including all top level and nested classes."
+      },
+      {
+        name: "methodMaximum",
+        default: "50",
+        description: "Specify the maximum allowed number of non commenting lines in a method."
+      },
+      {
+        name: "recordMaximum",
+        default: "150",
+        description: "Specify the maximum allowed number of non commenting lines in a record."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LambdaBodyLength",
+    category: "Complexity",
+    severityLevel: "Info",
+    title: "Enforce Lambda Body Length Limit",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "10",
+        description: "Specify the maximum number of lines allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LambdaParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Lambda Parameter Naming Conventions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^([a-z][a-zA-Z0-9]*|_)$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LeftCurly",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Left Curly Brace Placement",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreEnums",
+        default: "true",
+        description: "Allow to ignore enums when left curly brace policy is EOL."
+      },
+      {
+        name: "option",
+        default: "eol",
+        description: "Specify the policy on placement of a left curly brace ('{')."
+      },
+      {
+        name: "tokens",
+        default: "ANNOTATION_DEF, CLASS_DEF, CTOR_DEF, ENUM_CONSTANT_DEF, ENUM_DEF, INTERFACE_DEF, LAMBDA, LITERAL_CASE, LITERAL_CATCH, LITERAL_DEFAULT, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, METHOD_DEF, OBJBLOCK, STATIC_INIT, RECORD_DEF, COMPACT_CTOR_DEF, SWITCH_RULE",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LineEnding",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce configured file line endings",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "lineEnding",
+        default: "lf",
+        description: "Set lineEnding."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LineLength",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Line Length Limit",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "ignorePattern",
+        default: "^(package|import) .*",
+        description: "Specify pattern for lines to ignore."
+      },
+      {
+        name: "max",
+        default: "80",
+        description: "Specify the maximum line length allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LocalFinalVariableName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Local Final Variable Naming Convention",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^([a-z][a-zA-Z0-9]*|_)$",
+        description: "Sets the pattern to match valid identifiers."
+      },
+      {
+        name: "tokens",
+        default: "VARIABLE_DEF, PARAMETER_DEF, RESOURCE",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_LocalVariableName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Local Variable Naming Convention",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowOneCharVarInForLoop",
+        default: "false",
+        description: "Allow one character variable name in initialization expressions in FOR loop if one char variable name is prohibited by format regexp."
+      },
+      {
+        name: "format",
+        default: "^([a-z][a-zA-Z0-9]*|_)$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MagicNumber",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Magic Numbers",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "constantWaiverParentToken",
+        default: "ARRAY_INIT, ASSIGN, BAND, BNOT, BOR, BSR, BXOR, COLON, DIV, ELIST, EQUAL, EXPR, GE, GT, LE, LITERAL_NEW, LT, METHOD_CALL, MINUS, MOD, NOT_EQUAL, PLUS, QUESTION, SL, SR, STAR, TYPECAST, UNARY_MINUS, UNARY_PLUS",
+        description: "Specify tokens that are allowed in the AST path from the number literal to the enclosing constant definition."
+      },
+      {
+        name: "ignoreAnnotation",
+        default: "false",
+        description: "Ignore magic numbers in annotation declarations."
+      },
+      {
+        name: "ignoreAnnotationElementDefaults",
+        default: "true",
+        description: "Ignore magic numbers in annotation elements defaults."
+      },
+      {
+        name: "ignoreFieldDeclaration",
+        default: "false",
+        description: "Ignore magic numbers in field declarations."
+      },
+      {
+        name: "ignoreHashCodeMethod",
+        default: "false",
+        description: "Ignore magic numbers in hashCode methods."
+      },
+      {
+        name: "ignoreNumbers",
+        default: "-1, 0, 1, 2",
+        description: "Specify non-magic numbers."
+      },
+      {
+        name: "tokens",
+        default: "NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MatchXpath",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Custom Checks Using MatchXpath",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "query",
+        default: "",
+        description: "Specify Xpath query."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MemberName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Instance Variable Naming Convention",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "applyToPackage",
+        default: "true",
+        description: "Control if check should apply to package-private members."
+      },
+      {
+        name: "applyToPrivate",
+        default: "true",
+        description: "Control if check should apply to private members."
+      },
+      {
+        name: "applyToProtected",
+        default: "true",
+        description: "Control if check should apply to protected members."
+      },
+      {
+        name: "applyToPublic",
+        default: "true",
+        description: "Control if check should apply to public members."
+      },
+      {
+        name: "format",
+        default: "^[a-z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MethodCount",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Maximum Number of Methods per Class",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "maxPackage",
+        default: "100",
+        description: "Specify the maximum number of package methods allowed."
+      },
+      {
+        name: "maxPrivate",
+        default: "100",
+        description: "Specify the maximum number of private methods allowed."
+      },
+      {
+        name: "maxProtected",
+        default: "100",
+        description: "Specify the maximum number of protected methods allowed."
+      },
+      {
+        name: "maxPublic",
+        default: "100",
+        description: "Specify the maximum number of public methods allowed."
+      },
+      {
+        name: "maxTotal",
+        default: "100",
+        description: "Specify the maximum number of methods allowed at all scope levels."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, ENUM_CONSTANT_DEF, ENUM_DEF, INTERFACE_DEF, ANNOTATION_DEF, RECORD_DEF, COMPACT_COMPILATION_UNIT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MethodLength",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Long Methods",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "countEmpty",
+        default: "true",
+        description: "Control whether to count empty lines and comments."
+      },
+      {
+        name: "max",
+        default: "150",
+        description: "Specify the maximum number of lines allowed."
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MethodName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Method Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowClassName",
+        default: "false",
+        description: "Control whether to allow a method name to have the same name as the enclosing class name. Setting this property false helps to avoid confusion between constructors and methods."
+      },
+      {
+        name: "applyToPackage",
+        default: "true",
+        description: "Control if check should apply to package-private members."
+      },
+      {
+        name: "applyToPrivate",
+        default: "true",
+        description: "Control if check should apply to private members."
+      },
+      {
+        name: "applyToProtected",
+        default: "true",
+        description: "Control if check should apply to protected members."
+      },
+      {
+        name: "applyToPublic",
+        default: "true",
+        description: "Control if check should apply to public members."
+      },
+      {
+        name: "format",
+        default: "^[a-z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MethodParamPad",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Method Parameter Padding",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowLineBreaks",
+        default: "false",
+        description: "Allow a line break between the identifier and left parenthesis."
+      },
+      {
+        name: "option",
+        default: "nospace",
+        description: "Specify policy on how to pad method parameter."
+      },
+      {
+        name: "tokens",
+        default: "CTOR_DEF, CTOR_CALL, LITERAL_NEW, METHOD_CALL, METHOD_DEF, SUPER_CTOR_CALL, ENUM_CONSTANT_DEF, RECORD_DEF, RECORD_PATTERN_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MethodTypeParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Method Type Parameter Naming Convention",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[A-Z]$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MissingCtor",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Explicit Constructor Definition",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MissingDeprecated",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "EnforcePresenceOfBothDeprecatedAnnotationAndJavadocTag",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MissingJavadocMethod",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Comments on Methods",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowedAnnotations",
+        default: "Override",
+        description: "Configure annotations that allow missed documentation."
+      },
+      {
+        name: "allowMissingPropertyJavadoc",
+        default: "false",
+        description: "Control whether to allow missing Javadoc on accessor methods for properties (setters and getters)."
+      },
+      {
+        name: "excludeScope",
+        default: "null",
+        description: "Specify the visibility scope where Javadoc comments are not checked."
+      },
+      {
+        name: "ignoreMethodNamesRegex",
+        default: "null",
+        description: "Ignore method whose names are matching specified regex."
+      },
+      {
+        name: "minLineCount",
+        default: "-1",
+        description: "Control the minimal amount of lines in method to allow no documentation."
+      },
+      {
+        name: "scope",
+        default: "public",
+        description: "Specify the visibility scope where Javadoc comments are checked."
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF, ANNOTATION_FIELD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MissingJavadocPackage",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc for Package Definitions in package-info.java",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MissingJavadocType",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Javadoc Comments on Types",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "excludeScope",
+        default: "null",
+        description: "Specify the visibility scope where Javadoc comments are not checked."
+      },
+      {
+        name: "scope",
+        default: "public",
+        description: "Specify the visibility scope where Javadoc comments are checked."
+      },
+      {
+        name: "skipAnnotations",
+        default: "Generated",
+        description: "Specify annotations that allow missed documentation. If annotation is present in target sources in multiple forms of qualified name, all forms should be listed in this property."
+      },
+      {
+        name: "tokens",
+        default: "INTERFACE_DEF, CLASS_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MissingNullCaseInSwitch",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "EnforceNullCaseInSwitch",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MissingOverride",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Enforce @Override Annotation with @inheritDoc",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "javaFiveCompatibility",
+        default: "false",
+        description: "Enable java 5 compatibility mode."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MissingOverrideOnRecordAccessor",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Require @Override on Record Accessor",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MissingSwitchDefault",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "EnforceSwitchDefaultClause",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_ModifiedControlVariable",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Modifying For Loop Control Variable Inside Loop",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "skipEnhancedForLoopVariable",
+        default: "false",
+        description: "Control whether to check enhanced for-loop variable."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ModifierOrder",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Modifier Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MultiFileRegexpHeader",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Multi-File Regular Expression Header",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "headerFiles",
+        default: "null",
+        description: "Specify a comma-separated list of files containing the required headers. If a file's header matches none, the violation references the first file in this list. Users can order files to set a preferred header for such reporting."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MultilineCommentLeadingAsteriskPresence",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Require leading asterisk on each line of multi-line comments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MultipleStringLiterals",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Multiple Occurrences of the Same String Literal",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowedDuplicates",
+        default: "1",
+        description: "Specify the maximum number of occurrences to allow without generating a warning."
+      },
+      {
+        name: "ignoreOccurrenceContext",
+        default: "ANNOTATION",
+        description: "Specify token type names where duplicate strings are ignored even if they don't match ignoredStringsRegexp. This allows you to exclude syntactical contexts like annotations or static initializers from the check."
+      },
+      {
+        name: "ignoreStringsRegexp",
+        default: '^""$',
+        description: "Specify RegExp for ignored strings (with quotation marks)."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_MultipleVariableDeclarations",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Single Variable Declaration Per Statement",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_MutableException",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Immutability of Exception Classes",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "extendedClassNameFormat",
+        default: "^.*Exception$|^.*Error$|^.*Throwable$",
+        description: "Specify pattern for extended class names."
+      },
+      {
+        name: "format",
+        default: "^.*Exception$|^.*Error$|^.*Throwable$",
+        description: "Specify pattern for exception class names."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NeedBraces",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Braces Around Code Blocks",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowEmptyLoopBody",
+        default: "false",
+        description: "Allow loops with empty bodies."
+      },
+      {
+        name: "allowSingleLineStatement",
+        default: "false",
+        description: "Allow single-line statements without braces."
+      },
+      {
+        name: "tokens",
+        default: "LITERAL_DO, LITERAL_ELSE, LITERAL_FOR, LITERAL_IF, LITERAL_WHILE",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NestedForDepth",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Restrict Nested For Loop Depth",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "1",
+        description: "Specify maximum allowed nesting depth."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NestedIfDepth",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Restrict Nested If-Else Depth",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "1",
+        description: "Specify maximum allowed nesting depth."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NestedTryDepth",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Restrict Nested Try-Catch-Finally Depth",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "1",
+        description: "Specify maximum allowed nesting depth."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NewlineAtEndOfFile",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Newline at End of File",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "lineSeparator",
+        default: "lf_cr_crlf",
+        description: "Specify the type of line separator."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NoArrayTrailingComma",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Trailing Commas in Array Initializations",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NoClone",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Overriding clone Method",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NoCodeInFile",
+    category: "UnusedCode",
+    severityLevel: "Warning",
+    title: "Avoid Files Without Code",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NoEnumTrailingComma",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Trailing Comma in Enum Definitions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NoFinalizer",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Finalize Method",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NoLineWrap",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Line Wrapping in Statements",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "skipAnnotations",
+        default: "true",
+        description: "Specify whether to skip annotations to be part of target token."
+      },
+      {
+        name: "tokens",
+        default: "PACKAGE_DEF, IMPORT, STATIC_IMPORT, MODULE_IMPORT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NonEmptyAtclauseDescription",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Non-Empty @-Clause Description in Javadoc",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "javadocTokens",
+        default: "PARAM_BLOCK_TAG, RETURN_BLOCK_TAG, THROWS_BLOCK_TAG, EXCEPTION_BLOCK_TAG, DEPRECATED_BLOCK_TAG",
+        description: "javadoc tokens to check"
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NoWhitespaceAfter",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce No Whitespace After Token",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowLineBreaks",
+        default: "true",
+        description: "Control whether whitespace is allowed if the token is at a linebreak."
+      },
+      {
+        name: "tokens",
+        default: "ARRAY_INIT, AT, INC, DEC, UNARY_MINUS, UNARY_PLUS, BNOT, LNOT, DOT, ARRAY_DECLARATOR, INDEX_OP",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NoWhitespaceBefore",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Whitespace Before Tokens",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowLineBreaks",
+        default: "false",
+        description: "Control whether whitespace is allowed if the token is at a linebreak."
+      },
+      {
+        name: "tokens",
+        default: "COMMA, SEMI, POST_INC, POST_DEC, ELLIPSIS, LABELED_STAT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NoWhitespaceBeforeCaseDefaultColon",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "EnforceNoWhitespaceBeforeCaseDefaultColon",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_NPathComplexity",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce NPath Complexity Limit",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "200",
+        description: "Specify the maximum threshold allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_NumericalPrefixesInfixesSuffixesCharacterCase",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce lowercase in numerical literal prefixes, infixes, and suffixes",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_OneStatementPerLine",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce One Statement Per Line",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "treatTryResourcesAsStatement",
+        default: "false",
+        description: "Enable resources processing."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_OneTopLevelClass",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce One Top-Level Class per Source File",
+    enabled: true,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_OpenjdkAnnotationLocation",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce OpenJDK annotation placement",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, PACKAGE_DEF, ENUM_CONSTANT_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, RECORD_DEF, COMPACT_CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_OperatorWrap",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Operator Line Wrapping",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "nl",
+        description: "Specify policy on how to wrap lines."
+      },
+      {
+        name: "tokens",
+        default: "QUESTION, COLON, EQUAL, NOT_EQUAL, DIV, PLUS, MINUS, STAR, MOD, SR, BSR, GE, GT, SL, LE, LT, BXOR, BOR, LOR, BAND, LAND, TYPE_EXTENSION_AND, LITERAL_INSTANCEOF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_OrderedProperties",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Ordered Properties in Properties Files",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: ".properties",
+        description: "Specify the file extensions of the files to process."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_OuterTypeFilename",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Outer Type Name Matches File Name",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_OuterTypeNumber",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Single Outer Type per File",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "max",
+        default: "1",
+        description: "Specify the maximum number of outer types allowed."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_OverloadMethodsDeclarationOrder",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Overloaded Methods Declaration Order",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "orderByIncreasingParameterCount",
+        default: "false",
+        description: "Control whether to enforce order by increasing parameter count (arity) or not."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_PackageAnnotation",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Package Annotations in package-info.java",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_PackageDeclaration",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Package Declaration",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "matchDirectoryStructure",
+        default: "true",
+        description: "Control whether to check for directory and package name match."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_PackageName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Package Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[a-z]+(\\.[a-zA-Z_]\\w*)*$",
+        description: "Control the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ParameterAssignment",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Disallow Parameter Assignment",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_ParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Parameter Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "accessModifiers",
+        default: "public, protected, package, private",
+        description: "Access modifiers of methods where parameters are checked."
+      },
+      {
+        name: "format",
+        default: "^[a-z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      },
+      {
+        name: "ignoreOverridden",
+        default: "false",
+        description: "Allows to skip methods with Override annotation from validation."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ParameterNumber",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Limit Number of Parameters",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoreAnnotatedBy",
+        default: "",
+        description: "Ignore methods and constructors annotated with the specified annotation(s)."
+      },
+      {
+        name: "ignoreOverriddenMethods",
+        default: "false",
+        description: "Ignore number of parameters for methods with @Override annotation."
+      },
+      {
+        name: "max",
+        default: "7",
+        description: "Specify the maximum number of parameters allowed."
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ParenPad",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Parentheses Padding",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "nospace",
+        description: "Specify policy on how to pad parentheses."
+      },
+      {
+        name: "tokens",
+        default: "ANNOTATION, ANNOTATION_FIELD_DEF, CTOR_CALL, CTOR_DEF, DOT, ENUM_CONSTANT_DEF, EXPR, LITERAL_CATCH, LITERAL_DO, LITERAL_FOR, LITERAL_IF, LITERAL_NEW, LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_WHILE, METHOD_CALL, METHOD_DEF, QUESTION, RESOURCE_SPECIFICATION, SUPER_CTOR_CALL, LAMBDA, RECORD_DEF, RECORD_PATTERN_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_PatternVariableAssignment",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Pattern Variable Assignment",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_PatternVariableName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Pattern for Variable Names",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^([a-z][a-zA-Z0-9]*|_)$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RecordComponentName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Record Component Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[a-z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RecordComponentNumber",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Maximum Number of Record Components",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "accessModifiers",
+        default: "public, protected, package, private",
+        description: "Access modifiers of record definitions where the number of record components should be checked."
+      },
+      {
+        name: "max",
+        default: "8",
+        description: "Specify the maximum number of components allowed in the header of a record definition."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RecordTypeParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Record Type Parameter Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[A-Z]$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RedundantImport",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant Imports",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_RedundantModifier",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant Modifiers",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "jdkVersion",
+        default: "22",
+        description: "jdkVersion"
+      },
+      {
+        name: "tokens",
+        default: "METHOD_DEF, VARIABLE_DEF, ANNOTATION_FIELD_DEF, INTERFACE_DEF, CTOR_DEF, CLASS_DEF, ENUM_DEF, RESOURCE, ANNOTATION_DEF, RECORD_DEF, PATTERN_VARIABLE_DEF, LITERAL_CATCH, LAMBDA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_Regexp",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Regular Expression Pattern Matching in Files",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "duplicateLimit",
+        default: "0",
+        description: "Control whether to check for duplicates of a required pattern, any negative value means no checking for duplicates, any positive value is used as the maximum number of allowed duplicates, if the limit is exceeded violations will be logged."
+      },
+      {
+        name: "errorLimit",
+        default: "100",
+        description: "Specify the maximum number of violations before the check will abort."
+      },
+      {
+        name: "format",
+        default: "^$",
+        description: "Specify the pattern to match against."
+      },
+      {
+        name: "ignoreComments",
+        default: "false",
+        description: "Control whether to ignore matches found within comments."
+      },
+      {
+        name: "illegalPattern",
+        default: "false",
+        description: "Control whether the pattern is required or illegal."
+      },
+      {
+        name: "message",
+        default: "null",
+        description: "Specify message which is used to notify about violations, if empty then the default (hard-coded) message is used."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RegexpHeader",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Source File Header Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "header",
+        default: "null",
+        description: "header"
+      },
+      {
+        name: "headerFile",
+        default: "null",
+        description: "Specify the name of the file containing the required header."
+      },
+      {
+        name: "multiLines",
+        default: "",
+        description: "Specify the line numbers to repeat (zero or more times)."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RegexpMultiline",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Enforce Multiline Regular Expression Matching",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "format",
+        default: "$.",
+        description: "Specify the format of the regular expression to match."
+      },
+      {
+        name: "ignoreCase",
+        default: "false",
+        description: "Control whether to ignore case when searching."
+      },
+      {
+        name: "matchAcrossLines",
+        default: "false",
+        description: "Control whether to match expressions across multiple lines."
+      },
+      {
+        name: "maximum",
+        default: "0",
+        description: "Specify the maximum number of matches required in each file."
+      },
+      {
+        name: "message",
+        default: "null",
+        description: "Specify the message which is used to notify about violations, if empty then default (hard-coded) message is used."
+      },
+      {
+        name: "minimum",
+        default: "0",
+        description: "Specify the minimum number of matches required in each file."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RegexpOnFilename",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Filename Pattern Matching",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "fileNamePattern",
+        default: "null",
+        description: "Specify the regular expression to match the file name against."
+      },
+      {
+        name: "folderPattern",
+        default: "null",
+        description: "Specify the regular expression to match the folder path against."
+      },
+      {
+        name: "ignoreFileNameExtensions",
+        default: "false",
+        description: "Control whether to ignore the file extension for the file name match."
+      },
+      {
+        name: "match",
+        default: "true",
+        description: "Control whether to look for a match or mismatch on the file name, if the fileNamePattern is supplied, otherwise it is applied on the folderPattern."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RegexpSingleline",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Single-Line Pattern Matching",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: "",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "format",
+        default: "$.",
+        description: "Specify the format of the regular expression to match."
+      },
+      {
+        name: "ignoreCase",
+        default: "false",
+        description: "Control whether to ignore case when searching."
+      },
+      {
+        name: "maximum",
+        default: "0",
+        description: "Specify the maximum number of matches required in each file."
+      },
+      {
+        name: "message",
+        default: "null",
+        description: "Specify the message which is used to notify about violations, if empty then default (hard-coded) message is used."
+      },
+      {
+        name: "minimum",
+        default: "0",
+        description: "Specify the minimum number of matches required in each file."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RegexpSinglelineJava",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Detect Pattern Matches in Single Lines of Java Code",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "$.",
+        description: "Specify the format of the regular expression to match."
+      },
+      {
+        name: "ignoreCase",
+        default: "false",
+        description: "Control whether to ignore case when searching."
+      },
+      {
+        name: "ignoreComments",
+        default: "false",
+        description: "Control whether to ignore text in comments when searching."
+      },
+      {
+        name: "maximum",
+        default: "0",
+        description: "Specify the maximum number of matches required in each file."
+      },
+      {
+        name: "message",
+        default: "null",
+        description: "Specify the message which is used to notify about violations, if empty then default (hard-coded) message is used."
+      },
+      {
+        name: "minimum",
+        default: "0",
+        description: "Specify the minimum number of matches required in each file."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RequireEmptyLineBeforeBlockTagGroup",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Require Empty Line Before Javadoc Block Tag Group",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RequireThis",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "EnforceExplicitThisReference",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "checkFields",
+        default: "true",
+        description: "Control whether to check references to fields."
+      },
+      {
+        name: "checkMethods",
+        default: "true",
+        description: "Control whether to check references to methods."
+      },
+      {
+        name: "validateOnlyOverlapping",
+        default: "true",
+        description: "Control whether to check only overlapping by variables or arguments."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_ReturnCount",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Restrict Number of Return Statements",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^equals$",
+        description: "Specify method names to ignore."
+      },
+      {
+        name: "max",
+        default: "2",
+        description: "Specify maximum allowed number of return statements in non-void methods/lambdas."
+      },
+      {
+        name: "maxForVoid",
+        default: "1",
+        description: "Specify maximum allowed number of return statements in void methods/constructors/lambdas."
+      },
+      {
+        name: "tokens",
+        default: "CTOR_DEF, METHOD_DEF, LAMBDA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_RightCurly",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Right Curly Brace Placement",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "same",
+        description: "Specify the policy on placement of a right curly brace ('}')."
+      },
+      {
+        name: "tokens",
+        default: "LITERAL_TRY, LITERAL_CATCH, LITERAL_FINALLY, LITERAL_IF, LITERAL_ELSE",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_SealedShouldHavePermitsList",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Sealed Classes to Have Permits List",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SeparatorWrap",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Separator Line Wrapping",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "eol",
+        description: "Specify policy on how to wrap lines."
+      },
+      {
+        name: "tokens",
+        default: "DOT, COMMA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_SimplifyBooleanExpression",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Simplify Boolean Expression",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SimplifyBooleanReturn",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Simplify Boolean Return Statements",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SingleLineJavadoc",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Single-Line Javadoc Comments Without Block Tags",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignoredTags",
+        default: "",
+        description: "Specify block tags which are ignored by the check."
+      },
+      {
+        name: "ignoreInlineTags",
+        default: "true",
+        description: "Control whether inline tags must be ignored."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_SingleSpaceSeparator",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Single Space Separator Between Non-Whitespace Characters",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "validateComments",
+        default: "false",
+        description: "Control whether to validate whitespaces surrounding comments."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_StaticVariableName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Static Variable Naming Conventions",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "applyToPackage",
+        default: "true",
+        description: "Control if check should apply to package-private members."
+      },
+      {
+        name: "applyToPrivate",
+        default: "true",
+        description: "Control if check should apply to private members."
+      },
+      {
+        name: "applyToProtected",
+        default: "true",
+        description: "Control if check should apply to protected members."
+      },
+      {
+        name: "applyToPublic",
+        default: "true",
+        description: "Control if check should apply to public members."
+      },
+      {
+        name: "format",
+        default: "^[a-z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_StringLiteralEquality",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Using == or != for String Literal Equality",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SummaryJavadoc",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Avoid Non-Recommended Phrases in Javadoc Summary",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "forbiddenSummaryFragments",
+        default: "^$",
+        description: "Specify the regexp for forbidden summary fragments."
+      },
+      {
+        name: "period",
+        default: ".",
+        description: "period"
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_SuperClone",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Enforce Super Clone Invocation in Overriding clone() Method",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SuperFinalize",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Enforce Calling super.finalize() in Overriding finalize() Methods",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_SuppressWarnings",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Disallow Suppression of Specified Warnings",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^\\s*+$",
+        description: "Specify the RegExp to match against warnings. Any warning being suppressed matching this pattern will be flagged."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, ENUM_CONSTANT_DEF, PARAMETER_DEF, VARIABLE_DEF, METHOD_DEF, CTOR_DEF, COMPACT_CTOR_DEF, RECORD_DEF, PATTERN_VARIABLE_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_SuppressWarningsHolder",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Manage SuppressWarnings Annotations",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "aliasList",
+        default: "",
+        description: "Specify aliases for check names that can be used in code within SuppressWarnings in a format of comma separated attribute=value entries. The attribute is the fully qualified name of the Check and value is its alias."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TextBlockGoogleStyleFormatting",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Google-style Java Text Block Formatting",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_ThrowsCount",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Restrict Throws Count in Method Declarations",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "ignorePrivateMethods",
+        default: "true",
+        description: "Allow private methods to be ignored."
+      },
+      {
+        name: "max",
+        default: "4",
+        description: "Specify maximum allowed number of throws statements."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TodoComment",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Detect TODO Comments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "TODO:",
+        description: "Specify pattern to match comments against."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TrailingComment",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "AvoidTrailingEndOfLineComments",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "format",
+        default: "^[\\s});]*$",
+        description: "Specify pattern for strings allowed before the comment."
+      },
+      {
+        name: "legalComment",
+        default: "null",
+        description: "Define pattern for text allowed in trailing comments. This pattern will not be applied to multiline comments."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_Translation",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Consistent Translation Keys in Property Files",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "baseName",
+        default: "^messages.*$",
+        description: "Specify Base name of resource bundles which contain message resources. It helps the check to distinguish config and localization resources."
+      },
+      {
+        name: "fileExtensions",
+        default: ".properties",
+        description: "Specify the file extensions of the files to process."
+      },
+      {
+        name: "requiredTranslations",
+        default: "",
+        description: "Specify language codes of required translations which must exist in project."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TypeBodyPadding",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "EnforceTypeBodyPadding",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowEmpty",
+        default: "true",
+        description: "Allow empty type bodies to omit blank line padding."
+      },
+      {
+        name: "atEndOfBody",
+        default: "true",
+        description: "Require a blank line before the type body closing brace."
+      },
+      {
+        name: "atStartOfBody",
+        default: "true",
+        description: "Require a blank line after the type body opening brace."
+      },
+      {
+        name: "skipInner",
+        default: "true",
+        description: "Control whether to skip checking of inner types."
+      },
+      {
+        name: "skipLocal",
+        default: "true",
+        description: "Control whether to skip checking of local types."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, RECORD_DEF, ANNOTATION_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TypecastParenPad",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Typecast Parentheses Padding",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "option",
+        default: "nospace",
+        description: "Specify policy on how to pad parentheses."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_TypeName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Type Name Pattern",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "applyToPackage",
+        default: "true",
+        description: "Control if check should apply to package-private members."
+      },
+      {
+        name: "applyToPrivate",
+        default: "true",
+        description: "Control if check should apply to private members."
+      },
+      {
+        name: "applyToProtected",
+        default: "true",
+        description: "Control if check should apply to protected members."
+      },
+      {
+        name: "applyToPublic",
+        default: "true",
+        description: "Control if check should apply to public members."
+      },
+      {
+        name: "format",
+        default: "^[A-Z][a-zA-Z0-9]*$",
+        description: "Sets the pattern to match valid identifiers."
+      },
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UncommentedMain",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Uncommented Main Methods",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "excludedClasses",
+        default: "^$",
+        description: "Specify pattern for qualified names of classes which are allowed to have a main method."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UniqueProperties",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Detect Duplicate Keys in Properties Files",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "fileExtensions",
+        default: ".properties",
+        description: "Specify the file extensions of the files to process."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnnecessaryNullCheckWithInstanceOf",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Null Check with instanceof",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UnnecessaryParentheses",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Parentheses",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "EXPR, IDENT, NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG, STRING_LITERAL, LITERAL_NULL, LITERAL_FALSE, LITERAL_TRUE, ASSIGN, BAND_ASSIGN, BOR_ASSIGN, BSR_ASSIGN, BXOR_ASSIGN, DIV_ASSIGN, MINUS_ASSIGN, MOD_ASSIGN, PLUS_ASSIGN, SL_ASSIGN, SR_ASSIGN, STAR_ASSIGN, LAMBDA, TEXT_BLOCK_LITERAL_BEGIN, LAND, LOR, LITERAL_INSTANCEOF, GT, LT, GE, LE, EQUAL, NOT_EQUAL, UNARY_MINUS, UNARY_PLUS, INC, DEC, LNOT, BNOT, POST_INC, POST_DEC, INDEX_OP, DOT",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnnecessarySemicolonAfterOuterTypeDeclaration",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Semicolon After Outer Type Declaration",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnnecessarySemicolonAfterTypeMemberDeclaration",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Semicolon After Type Member Declaration",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "CLASS_DEF, INTERFACE_DEF, ENUM_DEF, ANNOTATION_DEF, VARIABLE_DEF, ANNOTATION_FIELD_DEF, STATIC_INIT, INSTANCE_INIT, CTOR_DEF, METHOD_DEF, ENUM_CONSTANT_DEF, COMPACT_CTOR_DEF, RECORD_DEF",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnnecessarySemicolonInEnumeration",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Semicolon in Enumeration",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UnnecessarySemicolonInTryWithResources",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unnecessary Semicolon in Try-With-Resources",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowWhenNoBraceAfterSemicolon",
+        default: "true",
+        description: "Allow unnecessary semicolon if closing parenthesis is not on the same line."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnnecessaryTypeArgumentsWithRecordPattern",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid unnecessary explicit type arguments in record patterns",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UnusedCatchParameterShouldBeUnnamed",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Unnamed Catch Parameters for Unused Variables",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UnusedImports",
+    category: "UnusedCode",
+    severityLevel: "Warning",
+    title: "Avoid Unused Imports",
+    enabled: true,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "processJavadoc",
+        default: "true",
+        description: "Control whether to process Javadoc comments."
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnusedLambdaParameterShouldBeUnnamed",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Unnamed Lambda Parameters for Unused Parameters",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UnusedLocalVariable",
+    category: "UnusedCode",
+    severityLevel: "Info",
+    title: "Avoid Unused Local Variables",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowUnnamedVariables",
+        default: "true",
+        description: "Allow variables named with a single underscore (known as unnamed variables in Java 21+)."
+      },
+      {
+        name: "jdkVersion",
+        default: "22",
+        description: "jdkVersion"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_UnusedTryResourceShouldBeUnnamed",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce unused try-with-resources be unnamed",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UpperEll",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Uppercase 'L' for Long Constants",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_UseEnhancedSwitch",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Use Enhanced Switch",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_VariableDeclarationUsageDistance",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Enforce Variable Declaration Usage Proximity",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowedDistance",
+        default: "3",
+        description: "Specify the maximum distance between a variable's declaration and its first usage. Value should be greater than 0."
+      },
+      {
+        name: "ignoreFinal",
+        default: "true",
+        description: "Allow to ignore variables with a 'final' modifier."
+      },
+      {
+        name: "ignoreVariablePattern",
+        default: "",
+        description: "Define RegExp to ignore distance calculation for variables listed in this pattern."
+      },
+      {
+        name: "validateBetweenScopes",
+        default: "false",
+        description: "Allow to calculate the distance between a variable's declaration and its first usage across different scopes."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_VisibilityModifier",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Visibility Modifiers for Class Members",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowPublicFinalFields",
+        default: "false",
+        description: "Allow final fields to be declared as public."
+      },
+      {
+        name: "allowPublicImmutableFields",
+        default: "false",
+        description: "Allow immutable fields to be declared as public if defined in final class."
+      },
+      {
+        name: "ignoreAnnotationCanonicalNames",
+        default: "com.google.common.annotations.VisibleForTesting, org.junit.ClassRule, org.junit.Rule",
+        description: "Specify annotations canonical names which ignore variables in consideration."
+      },
+      {
+        name: "immutableClassCanonicalNames",
+        default: "java.io.File, java.lang.Boolean, java.lang.Byte, java.lang.Character, java.lang.Double, java.lang.Float, java.lang.Integer, java.lang.Long, java.lang.Short, java.lang.StackTraceElement, java.lang.String, java.math.BigDecimal, java.math.BigInteger, java.net.Inet4Address, java.net.Inet6Address, java.net.InetSocketAddress, java.net.URI, java.net.URL, java.util.Locale, java.util.UUID",
+        description: "Specify immutable classes canonical names."
+      },
+      {
+        name: "packageAllowed",
+        default: "false",
+        description: "Control whether package visible members are allowed."
+      },
+      {
+        name: "protectedAllowed",
+        default: "false",
+        description: "Control whether protected members are allowed."
+      },
+      {
+        name: "publicMemberPattern",
+        default: "^serialVersionUID$",
+        description: "Specify pattern for public members that should be ignored."
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_WhenShouldBeUsed",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "EnforceUseOfWhenInSwitchCase",
+    enabled: false,
+    languages: ["Java"],
+    parameters: []
+  },
+  {
+    id: "Checkstyle_WhitespaceAfter",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Whitespace After Tokens",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "COMMA, SEMI, TYPECAST, LITERAL_IF, LITERAL_ELSE, LITERAL_WHILE, LITERAL_DO, LITERAL_FOR, LITERAL_FINALLY, LITERAL_RETURN, LITERAL_YIELD, LITERAL_CATCH, DO_WHILE, ELLIPSIS, LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_CASE, LAMBDA, LITERAL_WHEN",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_WhitespaceAround",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Whitespace Around Tokens",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "allowEmptyCatches",
+        default: "false",
+        description: "Allow empty catch bodies."
+      },
+      {
+        name: "allowEmptyConstructors",
+        default: "false",
+        description: "Allow empty constructor bodies."
+      },
+      {
+        name: "allowEmptyLambdas",
+        default: "false",
+        description: "Allow empty lambda bodies."
+      },
+      {
+        name: "allowEmptyLoops",
+        default: "false",
+        description: "Allow empty loop bodies."
+      },
+      {
+        name: "allowEmptyMethods",
+        default: "false",
+        description: "Allow empty method bodies."
+      },
+      {
+        name: "allowEmptySwitchBlockStatements",
+        default: "false",
+        description: "Allow empty switch blocks and block statements."
+      },
+      {
+        name: "allowEmptyTypes",
+        default: "false",
+        description: "Allow empty class, interface and enum bodies."
+      },
+      {
+        name: "ignoreEnhancedForColon",
+        default: "true",
+        description: "Ignore whitespace around colon in enhanced for loop."
+      },
+      {
+        name: "tokens",
+        default: "ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN, COLON, DIV, DIV_ASSIGN, DO_WHILE, EQUAL, GE, GT, LAMBDA, LAND, LCURLY, LE, LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN, LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, LOR, LT, MINUS, MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL, PLUS, PLUS_ASSIGN, QUESTION, RCURLY, SL, SLIST, SL_ASSIGN, SR, SR_ASSIGN, STAR, STAR_ASSIGN, LITERAL_ASSERT, TYPE_EXTENSION_AND, LITERAL_WHEN",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_WhitespaceBeforeEmptyBody",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Require whitespace before opening brace of empty body",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tokens",
+        default: "METHOD_DEF, CTOR_DEF, COMPACT_CTOR_DEF, CLASS_DEF, INTERFACE_DEF, RECORD_DEF, ENUM_DEF, ANNOTATION_DEF, LITERAL_NEW, LITERAL_DO, LITERAL_WHILE, LITERAL_FOR, LITERAL_IF, LITERAL_ELSE, STATIC_INIT, LITERAL_TRY, LITERAL_CATCH, LITERAL_FINALLY, LITERAL_SYNCHRONIZED, LITERAL_SWITCH, LAMBDA",
+        description: "tokens to check"
+      }
+    ]
+  },
+  {
+    id: "Checkstyle_WriteTag",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Presence and Format of User Defined Javadoc Tag",
+    enabled: false,
+    languages: ["Java"],
+    parameters: [
+      {
+        name: "tag",
+        default: "null",
+        description: "Specify the name of tag."
+      },
+      {
+        name: "tagFormat",
+        default: "null",
+        description: "Specify the regexp to match tag content."
+      },
+      {
+        name: "tagSeverity",
+        default: "info",
+        description: "Specify the severity level when tag is found and printed."
+      },
+      {
+        name: "tokens",
+        default: "INTERFACE_DEF, CLASS_DEF, ENUM_DEF, ANNOTATION_DEF, RECORD_DEF",
+        description: "tokens to check"
+      },
+      {
+        name: "violateExecutionOnNonTightHtml",
+        default: "false",
+        description: "Control when to print violations if the Javadoc being examined by this check violates the tight html rules defined at Tight-HTML Rules."
+      }
+    ]
+  }
+];
+
+// src/metadata.ts
+var descriptor = {
+  id: "Checkstyle",
+  displayName: "Checkstyle",
+  preferredVersion: "13.9.0",
+  languages: ["Java"],
+  filePatterns: ["**/*.java"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"]
+};
+
+// src/adapter.ts
+var TOOL_ID = "Checkstyle";
+var CHECKSTYLE_VERSION = "13.9.0";
+var JAR_NAME = `checkstyle-${CHECKSTYLE_VERSION}-all.jar`;
+var JAR_URL = `https://github.com/checkstyle/checkstyle/releases/download/checkstyle-${CHECKSTYLE_VERSION}/${JAR_NAME}`;
+var JAVA_VERSION_RANGE = ">=21";
+var GLOBAL_MODULES = /* @__PURE__ */ new Set([
+  "Header",
+  "RegexpHeader",
+  "MultiFileRegexpHeader",
+  "JavadocPackage",
+  "Translation",
+  "RegexpMultiline",
+  "RegexpSingleline",
+  "RegexpOnFilename",
+  "FileLength",
+  "FileTabCharacter",
+  "NewlineAtEndOfFile",
+  "UniqueProperties",
+  "LineLength",
+  "OrderedProperties",
+  "SeverityMatchFilter",
+  "SuppressionCommentFilter",
+  "SuppressionFilter",
+  "SuppressWithNearbyCommentFilter",
+  "SuppressWarningsFilter"
+]);
+var PATTERN_ID_ALIASES = /* @__PURE__ */ new Map([
+  ["UnnecessaryNullWithInstanceOf", "UnnecessaryNullCheckWithInstanceOf"]
+]);
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: p.category,
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(patternId) {
+  return PATTERN_META.get(patternId) ?? { category: "CodeStyle", severity: "Info" };
+}
+var xmlParser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: (name) => name === "file" || name === "error",
+  processEntities: {
+    enabled: true,
+    maxTotalExpansions: 1e5
+  }
+});
+function extractCheckName(source) {
+  const lastDot = source.lastIndexOf(".");
+  let name = lastDot >= 0 ? source.substring(lastDot + 1) : source;
+  if (name.endsWith("Check")) {
+    name = name.slice(0, -5);
+  }
+  return name;
+}
+async function resolveJarPath(ctx) {
+  const codacyJar = import_path.default.join(ctx.toolInstallDir, JAR_NAME);
+  try {
+    await import_promises.default.access(codacyJar);
+    return codacyJar;
+  } catch {
+    return null;
+  }
+}
+var CHECK_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+var MAX_CONFIG_REPAIRS = 8;
+function extractUninstantiableModule(stderr) {
+  const match = stderr.match(/Unable to instantiate '([\w$.]+)' class/);
+  if (!match) return void 0;
+  const name = match[1];
+  const lastDot = name.lastIndexOf(".");
+  return lastDot >= 0 ? name.slice(lastDot + 1) : name;
+}
+function generateCheckstyleConfig(patterns) {
+  const globalModules = [];
+  const treeWalkerModules = [];
+  for (const pattern of patterns) {
+    const prefix = `${TOOL_ID}_`;
+    if (!pattern.patternId.startsWith(prefix)) continue;
+    const checkName = pattern.patternId.slice(prefix.length);
+    if (!CHECK_NAME_PATTERN.test(checkName)) continue;
+    if (GLOBAL_MODULES.has(checkName)) {
+      globalModules.push(`  <module name="${checkName}"/>`);
+    } else {
+      treeWalkerModules.push(`    <module name="${checkName}"/>`);
+    }
+  }
+  const lines = [
+    `<?xml version="1.0"?>`,
+    `<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN" "https://checkstyle.org/dtds/configuration_1_3.dtd">`,
+    `<module name="Checker">`,
+    ...globalModules,
+    `  <module name="SuppressWarningsFilter"/>`,
+    `  <module name="TreeWalker">`,
+    ...treeWalkerModules,
+    `    <module name="SuppressionCommentFilter"/>`,
+    `    <module name="SuppressWarningsHolder"/>`,
+    `  </module>`,
+    `</module>`
+  ];
+  return lines.join("\n") + "\n";
+}
+var CONFIG_FILE_CANDIDATE = "checkstyle.xml";
+var adapter = {
+  ...descriptor,
+  patternsMetadata: patterns_default,
+  compatibleVersions: ">=13.0.0",
+  website: "https://checkstyle.org",
+  prerequisites: [
+    {
+      name: "Java",
+      versionRange: JAVA_VERSION_RANGE,
+      preferredVersion: "21",
+      checkCommand: "java -version"
+    }
+  ],
+  /**
+   * Checks whether Checkstyle is available by detecting Java and the JAR.
+   *
+   * Reports Java as a dependency. Checkstyle is considered available if:
+   * 1. Java 11+ is found on the system or in the Codacy-managed JRE
+   * 2. The Checkstyle fat JAR exists in the tool install directory
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    const { java: javaInfo, dependency: javaDep } = await (0, import_tooling.checkJavaRuntime)(
+      ctx.globalDir,
+      JAVA_VERSION_RANGE,
+      ctx.logger
+    );
+    const dependencies = [javaDep];
+    const jarPath = await resolveJarPath(ctx);
+    if (jarPath && javaInfo) {
+      ctx.logger.debug("Checkstyle available", { toolId: TOOL_ID, version: CHECKSTYLE_VERSION });
+      return {
+        available: true,
+        version: CHECKSTYLE_VERSION,
+        path: jarPath,
+        installation: "codacy",
+        dependencies
+      };
+    }
+    if (javaInfo && !jarPath) {
+      ctx.logger.debug("Checkstyle JAR not found", { toolId: TOOL_ID });
+      return {
+        available: false,
+        reason: `Checkstyle JAR not found at ${import_path.default.join(ctx.toolInstallDir, JAR_NAME)}`,
+        installHint: "codacy-analysis analyze . --install-dependencies  # auto-download JAR",
+        dependencies
+      };
+    }
+    ctx.logger.debug("Checkstyle not found", { toolId: TOOL_ID });
+    return {
+      available: false,
+      reason: "Java runtime and/or Checkstyle JAR not found",
+      installHint: "Install Java 11+ and run: codacy-analysis analyze . --install-dependencies",
+      dependencies
+    };
+  },
+  /**
+   * Installs Checkstyle by ensuring a JRE is available and downloading
+   * the fat JAR from GitHub releases.
+   *
+   * Uses ensureJre() to download Adoptium Temurin JDK 17 if no system
+   * Java 11+ is found, then downloads the Checkstyle all-in-one JAR.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    const java = await (0, import_tooling.ensureJre)(ctx.globalDir, JAVA_VERSION_RANGE, ctx.logger);
+    if (!java) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "requirementCheck",
+          kind: "MissingPrerequisite",
+          message: `Java (${JAVA_VERSION_RANGE}) could not be found or downloaded. Checkstyle 10.x requires Java 11+.`,
+          level: "error"
+        }
+      };
+    }
+    try {
+      ctx.logger.info(`Downloading Checkstyle ${CHECKSTYLE_VERSION} JAR...`);
+      const jarPath = await (0, import_tooling.downloadJar)(JAR_URL, ctx.toolInstallDir, JAR_NAME, ctx.logger);
+      ctx.logger.info(`Downloaded Checkstyle to ${jarPath}`);
+      await (0, import_tooling.pruneSupersededArtifacts)(
+        ctx.toolInstallDir,
+        JAR_NAME,
+        (name) => /^checkstyle-.*-all\.jar$/.test(name),
+        ctx.logger
+      );
+      return { success: true, installedPath: jarPath, installedVersion: CHECKSTYLE_VERSION };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "InstallError",
+          message: `Failed to download Checkstyle JAR: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      };
+    }
+  },
+  /**
+   * Checks for a `checkstyle.xml` configuration file in the repository root.
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    const candidatePath = import_path.default.join(ctx.repositoryRoot, CONFIG_FILE_CANDIDATE);
+    try {
+      await import_promises.default.access(candidatePath);
+      ctx.logger.debug("Local config found", { toolId: TOOL_ID, path: candidatePath });
+      return { found: true, path: candidatePath };
+    } catch {
+      return { found: false };
+    }
+  },
+  /**
+   * Runs Checkstyle via `java -jar checkstyle-13.9.0-all.jar` against the
+   * target files and converts the XML output into Codacy Issue objects.
+   *
+   * Config resolution:
+   * - If `useLocalConfigurationFile` is true and a local config is found,
+   *   passes `-c <path>` to use the project's checkstyle.xml.
+   * - If patterns are specified and no local config is in use, generates
+   *   a temporary checkstyle.xml with the enabled modules.
+   * - Otherwise (no local config and no patterns), skips execution.
+   *
+   * Exit codes:
+   * - 0: no violations found
+   * - >0: violations found (normal — parse XML output)
+   * - -1: bad arguments
+   * - -2: internal crash
+   *
+   * The XML output contains `<file>` elements with `<error>` children.
+   * `file/@name` is an absolute path converted to repo-relative.
+   * `error/@source` is an FQCN from which we extract the check name.
+   *
+   * Never throws — all errors are captured in the returned `errors` array.
+   */
+  async analyze(ctx, codacyConfig) {
+    const startMs = Date.now();
+    ctx.logger.info("Starting analysis", { toolId: TOOL_ID, fileCount: ctx.targetFiles.length });
+    const startedAt = /* @__PURE__ */ new Date();
+    const issues = [];
+    const errors = [];
+    if (ctx.targetFiles.length === 0) {
+      return (0, import_tooling.buildResult)(TOOL_ID, startedAt, /* @__PURE__ */ new Date(), issues, errors, 0);
+    }
+    const useLocal = codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile;
+    const resolved = await (0, import_tooling.resolveJava)(ctx.globalDir, JAVA_VERSION_RANGE, ctx.logger);
+    const javaBinary = resolved?.path ?? "java";
+    const jarPath = await resolveJarPath(ctx);
+    if (!jarPath) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "MissingPrerequisite",
+        message: `Checkstyle JAR not found at ${import_path.default.join(ctx.toolInstallDir, JAR_NAME)}. Run install first.`,
+        level: "error"
+      });
+      return (0, import_tooling.buildResult)(TOOL_ID, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    const absoluteFiles = ctx.targetFiles.map((f) => import_path.default.resolve(ctx.repositoryRoot, f));
+    const args = ["-jar", jarPath];
+    let generatedConfigPath = null;
+    if (useLocal) {
+      args.push("-c", codacyConfig.localConfigurationFile);
+    } else if (codacyConfig.patterns.length > 0) {
+      const configXml = generateCheckstyleConfig(codacyConfig.patterns);
+      generatedConfigPath = import_path.default.join(ctx.generatedConfigDir, "checkstyle.xml");
+      await import_promises.default.mkdir(ctx.generatedConfigDir, { recursive: true });
+      await import_promises.default.writeFile(generatedConfigPath, configXml, "utf-8");
+      args.push("-c", generatedConfigPath);
+    } else {
+      ctx.logger.info("Skipping analysis: no local config and no patterns enabled", {
+        toolId: TOOL_ID
+      });
+      return (0, import_tooling.buildResult)(TOOL_ID, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    args.push("-f", "xml");
+    const fileChunks = (0, import_tooling.chunkFilesForArgv)(absoluteFiles);
+    try {
+      const checkstyleFiles = [];
+      let activePatterns = codacyConfig.patterns;
+      let configRepairs = 0;
+      for (let chunkIdx = 0; chunkIdx < fileChunks.length; chunkIdx++) {
+        const chunk = fileChunks[chunkIdx];
+        const { stdout, stderr, exitCode } = await (0, import_tooling.spawnTool)(javaBinary, [...args, ...chunk], {
+          cwd: ctx.repositoryRoot,
+          logger: ctx.logger
+        });
+        if (generatedConfigPath && configRepairs < MAX_CONFIG_REPAIRS) {
+          const badModule = extractUninstantiableModule(stderr);
+          if (badModule) {
+            configRepairs++;
+            const before = activePatterns.length;
+            activePatterns = activePatterns.filter(
+              (p) => p.patternId !== `${TOOL_ID}_${badModule}`
+            );
+            ctx.logger.debug("Retrying without a module this Checkstyle version lacks", {
+              toolId: TOOL_ID,
+              module: badModule,
+              attempt: configRepairs
+            });
+            if (activePatterns.length < before && activePatterns.length > 0) {
+              await import_promises.default.writeFile(
+                generatedConfigPath,
+                generateCheckstyleConfig(activePatterns),
+                "utf-8"
+              );
+              chunkIdx--;
+              continue;
+            }
+          }
+        }
+        if (exitCode < 0) {
+          errors.push({
+            toolId: TOOL_ID,
+            phase: "toolInvoke",
+            kind: "NonZeroExit",
+            message: `Checkstyle exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`,
+            level: "error"
+          });
+          return (0, import_tooling.buildResult)(
+            TOOL_ID,
+            startedAt,
+            /* @__PURE__ */ new Date(),
+            issues,
+            errors,
+            ctx.targetFiles.length
+          );
+        }
+        if (!stdout.trim()) {
+          if (exitCode > 0) {
+            errors.push({
+              toolId: TOOL_ID,
+              phase: "toolInvoke",
+              kind: "NonZeroExit",
+              message: stderr.trim() ? `Checkstyle exited with code ${exitCode}: ${stderr.trim()}` : `Checkstyle exited with code ${exitCode} and produced no output`,
+              level: "error"
+            });
+            return (0, import_tooling.buildResult)(
+              TOOL_ID,
+              startedAt,
+              /* @__PURE__ */ new Date(),
+              issues,
+              errors,
+              ctx.targetFiles.length
+            );
+          }
+          continue;
+        }
+        let parsedFiles;
+        try {
+          const parsed = xmlParser.parse(stdout);
+          parsedFiles = parsed?.checkstyle?.file ?? [];
+        } catch (err) {
+          errors.push({
+            toolId: TOOL_ID,
+            phase: "outputParse",
+            kind: "MalformedOutput",
+            message: `Failed to parse Checkstyle XML output: ${err instanceof Error ? err.message : String(err)}`,
+            level: "error"
+          });
+          return (0, import_tooling.buildResult)(
+            TOOL_ID,
+            startedAt,
+            /* @__PURE__ */ new Date(),
+            issues,
+            errors,
+            ctx.targetFiles.length
+          );
+        }
+        const stderrFiltered = stderr.split("\n").filter((line) => {
+          const trimmed = line.trim();
+          if (!trimmed) return false;
+          if (trimmed.startsWith("Starting audit...")) return false;
+          if (trimmed.startsWith("Audit done.")) return false;
+          if (trimmed.startsWith("Checkstyle ends with")) return false;
+          return true;
+        }).join("\n").trim();
+        if (stderrFiltered) {
+          errors.push({
+            toolId: TOOL_ID,
+            phase: "outputParse",
+            kind: "ParseWarning",
+            message: `Checkstyle stderr: ${stderrFiltered}`,
+            level: "warning"
+          });
+        }
+        checkstyleFiles.push(...parsedFiles);
+      }
+      const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+      for (const file of checkstyleFiles) {
+        const absoluteFilePath = file["@_name"];
+        if (!absoluteFilePath) continue;
+        const fileErrors = file.error ?? [];
+        if (fileErrors.length === 0) continue;
+        const lines = await (0, import_tooling.readFileLines)(absoluteFilePath);
+        const relPath = import_path.default.relative(ctx.repositoryRoot, absoluteFilePath);
+        for (const error of fileErrors) {
+          const source = error["@_source"];
+          if (!source) continue;
+          let checkName = extractCheckName(source);
+          checkName = PATTERN_ID_ALIASES.get(checkName) ?? checkName;
+          const patternId = `${TOOL_ID}_${checkName}`;
+          if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) {
+            continue;
+          }
+          const line = parseInt(error["@_line"], 10) || 1;
+          const column = parseInt(error["@_column"] ?? "1", 10) || 1;
+          const meta = ruleMetadata(patternId);
+          issues.push({
+            filePath: relPath,
+            patternId,
+            toolId: TOOL_ID,
+            line,
+            column,
+            message: error["@_message"],
+            lineContent: (0, import_tooling.getLineContent)(lines, line),
+            category: meta.category,
+            severity: meta.severity
+          });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to run Checkstyle: ${err instanceof Error ? err.message : String(err)}`,
+        level: "error"
+      });
+    } finally {
+      if (generatedConfigPath) {
+        await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+      }
+    }
+    const durationMs = Date.now() - startMs;
+    ctx.logger.info("Analysis complete", {
+      toolId: TOOL_ID,
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs
+    });
+    return (0, import_tooling.buildResult)(TOOL_ID, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+  }
+};
+
+// src/index.ts
+var index_default = (0, import_tooling2.defineToolAdapter)(adapter);