diff --git a/.changeset/sharp-geckos-see.md b/.changeset/sharp-geckos-see.md
new file mode 100644
index 000000000000..b6018e3decac
--- /dev/null
+++ b/.changeset/sharp-geckos-see.md
@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#9314](https://github.com/biomejs/biome/issues/9314). Now Biome doesn't panic when `useAriaPropsForRole` is configured using an object.
diff --git a/crates/biome_configuration/Cargo.toml b/crates/biome_configuration/Cargo.toml
index 409663afec55..53348bbd96b6 100644
--- a/crates/biome_configuration/Cargo.toml
+++ b/crates/biome_configuration/Cargo.toml
@@ -60,9 +60,9 @@ tikv-jemallocator = { workspace = true }
 mimalloc = { workspace = true }
 
 [features]
-default  = []
-markdown = []
-schema   = [
+default    = []
+markdown   = []
+schema     = [
   "biome_analyze/schema",
   "biome_formatter/schema",
   "biome_html_formatter/schema",
@@ -74,6 +74,7 @@ schema   = [
   "biome_rule_options/schema",
   "dep:schemars",
 ]
+test-utils = []
 
 [lints]
 workspace = true
diff --git a/crates/biome_configuration/src/generated.rs b/crates/biome_configuration/src/generated.rs
index d1e538e1788f..2c5d5c758e94 100644
--- a/crates/biome_configuration/src/generated.rs
+++ b/crates/biome_configuration/src/generated.rs
@@ -1,6 +1,8 @@
 mod assist;
 mod domain_selector;
 mod linter;
+#[cfg(any(test, feature = "test-utils"))]
+pub mod linter_options_check;
 
 pub use assist::push_to_analyzer_assist;
 pub use linter::push_to_analyzer_rules;
diff --git a/crates/biome_configuration/src/generated/linter_options_check.rs b/crates/biome_configuration/src/generated/linter_options_check.rs
new file mode 100644
index 000000000000..a8ed4a8de2a5
--- /dev/null
+++ b/crates/biome_configuration/src/generated/linter_options_check.rs
@@ -0,0 +1,2190 @@
+//! Generated file, do not edit by hand, see `xtask/codegen`
+
+#![expect(clippy::vec_init_then_push)]
+use std::any::TypeId;
+
+/// Returns a list of `(group, rule, config_side_type_id)` for every lint rule.
+///
+/// The `TypeId` is derived from the rule name convention:
+/// `biome_rule_options::{snake_case_name}::{PascalCaseName}Options`
+///
+/// This is the type that the configuration layer uses when constructing
+/// [`RuleOptions`](biome_analyze::options::RuleOptions). If the rule's
+/// `type Options` doesn't match, the `debug_assert_eq!` inside
+/// `RuleOptions::value()` will fire at runtime.
+pub fn config_side_rule_options_types() -> Vec<(&'static str, &'static str, TypeId)> {
+    let mut result = Vec::new();
+    result.push((
+        "a11y",
+        "noAccessKey",
+        TypeId::of::<biome_rule_options::no_access_key::NoAccessKeyOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noAccumulatingSpread",
+        TypeId::of::<biome_rule_options::no_accumulating_spread::NoAccumulatingSpreadOptions>(),
+    ));
+    result.push(("complexity", "noAdjacentSpacesInRegex", TypeId::of::<biome_rule_options::no_adjacent_spaces_in_regex::NoAdjacentSpacesInRegexOptions>()));
+    result.push((
+        "suspicious",
+        "noAlert",
+        TypeId::of::<biome_rule_options::no_alert::NoAlertOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noAmbiguousAnchorText",
+        TypeId::of::<biome_rule_options::no_ambiguous_anchor_text::NoAmbiguousAnchorTextOptions>(),
+    ));
+    result.push(("suspicious", "noApproximativeNumericConstant", TypeId::of::<biome_rule_options::no_approximative_numeric_constant::NoApproximativeNumericConstantOptions>()));
+    result.push((
+        "complexity",
+        "noArguments",
+        TypeId::of::<biome_rule_options::no_arguments::NoArgumentsOptions>(),
+    ));
+    result.push(("a11y", "noAriaHiddenOnFocusable", TypeId::of::<biome_rule_options::no_aria_hidden_on_focusable::NoAriaHiddenOnFocusableOptions>()));
+    result.push((
+        "a11y",
+        "noAriaUnsupportedElements",
+        TypeId::of::<
+            biome_rule_options::no_aria_unsupported_elements::NoAriaUnsupportedElementsOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noArrayIndexKey",
+        TypeId::of::<biome_rule_options::no_array_index_key::NoArrayIndexKeyOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noAssignInExpressions",
+        TypeId::of::<biome_rule_options::no_assign_in_expressions::NoAssignInExpressionsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noAsyncPromiseExecutor",
+        TypeId::of::<biome_rule_options::no_async_promise_executor::NoAsyncPromiseExecutorOptions>(
+        ),
+    ));
+    result.push((
+        "a11y",
+        "noAutofocus",
+        TypeId::of::<biome_rule_options::no_autofocus::NoAutofocusOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noAwaitInLoops",
+        TypeId::of::<biome_rule_options::no_await_in_loops::NoAwaitInLoopsOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noBannedTypes",
+        TypeId::of::<biome_rule_options::no_banned_types::NoBannedTypesOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noBarrelFile",
+        TypeId::of::<biome_rule_options::no_barrel_file::NoBarrelFileOptions>(),
+    ));
+    result.push(("nursery", "noBeforeInteractiveScriptOutsideDocument", TypeId::of::<biome_rule_options::no_before_interactive_script_outside_document::NoBeforeInteractiveScriptOutsideDocumentOptions>()));
+    result.push((
+        "suspicious",
+        "noBiomeFirstException",
+        TypeId::of::<biome_rule_options::no_biome_first_exception::NoBiomeFirstExceptionOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noBitwiseOperators",
+        TypeId::of::<biome_rule_options::no_bitwise_operators::NoBitwiseOperatorsOptions>(),
+    ));
+    result.push((
+        "security",
+        "noBlankTarget",
+        TypeId::of::<biome_rule_options::no_blank_target::NoBlankTargetOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noCatchAssign",
+        TypeId::of::<biome_rule_options::no_catch_assign::NoCatchAssignOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noChildrenProp",
+        TypeId::of::<biome_rule_options::no_children_prop::NoChildrenPropOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noClassAssign",
+        TypeId::of::<biome_rule_options::no_class_assign::NoClassAssignOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noCommaOperator",
+        TypeId::of::<biome_rule_options::no_comma_operator::NoCommaOperatorOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noCommentText",
+        TypeId::of::<biome_rule_options::no_comment_text::NoCommentTextOptions>(),
+    ));
+    result.push((
+        "style",
+        "noCommonJs",
+        TypeId::of::<biome_rule_options::no_common_js::NoCommonJsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noCompareNegZero",
+        TypeId::of::<biome_rule_options::no_compare_neg_zero::NoCompareNegZeroOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noConditionalExpect",
+        TypeId::of::<biome_rule_options::no_conditional_expect::NoConditionalExpectOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noConfusingLabels",
+        TypeId::of::<biome_rule_options::no_confusing_labels::NoConfusingLabelsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noConfusingVoidType",
+        TypeId::of::<biome_rule_options::no_confusing_void_type::NoConfusingVoidTypeOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noConsole",
+        TypeId::of::<biome_rule_options::no_console::NoConsoleOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noConstAssign",
+        TypeId::of::<biome_rule_options::no_const_assign::NoConstAssignOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noConstEnum",
+        TypeId::of::<biome_rule_options::no_const_enum::NoConstEnumOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noConstantBinaryExpressions",
+        TypeId::of::<
+            biome_rule_options::no_constant_binary_expressions::NoConstantBinaryExpressionsOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noConstantCondition",
+        TypeId::of::<biome_rule_options::no_constant_condition::NoConstantConditionOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noConstantMathMinMaxClamp",
+        TypeId::of::<
+            biome_rule_options::no_constant_math_min_max_clamp::NoConstantMathMinMaxClampOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noConstructorReturn",
+        TypeId::of::<biome_rule_options::no_constructor_return::NoConstructorReturnOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noContinue",
+        TypeId::of::<biome_rule_options::no_continue::NoContinueOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noControlCharactersInRegex",
+        TypeId::of::<
+            biome_rule_options::no_control_characters_in_regex::NoControlCharactersInRegexOptions,
+        >(),
+    ));
+    result.push((
+        "security",
+        "noDangerouslySetInnerHtml",
+        TypeId::of::<
+            biome_rule_options::no_dangerously_set_inner_html::NoDangerouslySetInnerHtmlOptions,
+        >(),
+    ));
+    result.push(("security", "noDangerouslySetInnerHtmlWithChildren", TypeId::of::<biome_rule_options::no_dangerously_set_inner_html_with_children::NoDangerouslySetInnerHtmlWithChildrenOptions>()));
+    result.push((
+        "suspicious",
+        "noDebugger",
+        TypeId::of::<biome_rule_options::no_debugger::NoDebuggerOptions>(),
+    ));
+    result.push((
+        "style",
+        "noDefaultExport",
+        TypeId::of::<biome_rule_options::no_default_export::NoDefaultExportOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noDelete",
+        TypeId::of::<biome_rule_options::no_delete::NoDeleteOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDeprecatedImports",
+        TypeId::of::<biome_rule_options::no_deprecated_imports::NoDeprecatedImportsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noDeprecatedMediaType",
+        TypeId::of::<biome_rule_options::no_deprecated_media_type::NoDeprecatedMediaTypeOptions>(),
+    ));
+    result.push((
+        "style",
+        "noDescendingSpecificity",
+        TypeId::of::<biome_rule_options::no_descending_specificity::NoDescendingSpecificityOptions>(
+        ),
+    ));
+    result.push((
+        "a11y",
+        "noDistractingElements",
+        TypeId::of::<biome_rule_options::no_distracting_elements::NoDistractingElementsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noDivRegex",
+        TypeId::of::<biome_rule_options::no_div_regex::NoDivRegexOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDocumentCookie",
+        TypeId::of::<biome_rule_options::no_document_cookie::NoDocumentCookieOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDocumentImportInPage",
+        TypeId::of::<biome_rule_options::no_document_import_in_page::NoDocumentImportInPageOptions>(
+        ),
+    ));
+    result.push((
+        "style",
+        "noDoneCallback",
+        TypeId::of::<biome_rule_options::no_done_callback::NoDoneCallbackOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDoubleEquals",
+        TypeId::of::<biome_rule_options::no_double_equals::NoDoubleEqualsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noDuplicateArgumentNames",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_argument_names::NoDuplicateArgumentNamesOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateAtImportRules",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_at_import_rules::NoDuplicateAtImportRulesOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noDuplicateAttributes",
+        TypeId::of::<biome_rule_options::no_duplicate_attributes::NoDuplicateAttributesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateCase",
+        TypeId::of::<biome_rule_options::no_duplicate_case::NoDuplicateCaseOptions>(),
+    ));
+    result.push(("suspicious", "noDuplicateClassMembers", TypeId::of::<biome_rule_options::no_duplicate_class_members::NoDuplicateClassMembersOptions>()));
+    result.push((
+        "suspicious",
+        "noDuplicateCustomProperties",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_custom_properties::NoDuplicateCustomPropertiesOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateDependencies",
+        TypeId::of::<biome_rule_options::no_duplicate_dependencies::NoDuplicateDependenciesOptions>(
+        ),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateElseIf",
+        TypeId::of::<biome_rule_options::no_duplicate_else_if::NoDuplicateElseIfOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noDuplicateEnumValueNames",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_enum_value_names::NoDuplicateEnumValueNamesOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noDuplicateEnumValues",
+        TypeId::of::<biome_rule_options::no_duplicate_enum_values::NoDuplicateEnumValuesOptions>(),
+    ));
+    result.push(("nursery", "noDuplicateFieldDefinitionNames", TypeId::of::<biome_rule_options::no_duplicate_field_definition_names::NoDuplicateFieldDefinitionNamesOptions>()));
+    result.push((
+        "suspicious",
+        "noDuplicateFields",
+        TypeId::of::<biome_rule_options::no_duplicate_fields::NoDuplicateFieldsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateFontNames",
+        TypeId::of::<biome_rule_options::no_duplicate_font_names::NoDuplicateFontNamesOptions>(),
+    ));
+    result.push(("nursery", "noDuplicateGraphqlOperationName", TypeId::of::<biome_rule_options::no_duplicate_graphql_operation_name::NoDuplicateGraphqlOperationNameOptions>()));
+    result.push((
+        "nursery",
+        "noDuplicateInputFieldNames",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_input_field_names::NoDuplicateInputFieldNamesOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateJsxProps",
+        TypeId::of::<biome_rule_options::no_duplicate_jsx_props::NoDuplicateJsxPropsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateObjectKeys",
+        TypeId::of::<biome_rule_options::no_duplicate_object_keys::NoDuplicateObjectKeysOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateParameters",
+        TypeId::of::<biome_rule_options::no_duplicate_parameters::NoDuplicateParametersOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noDuplicateProperties",
+        TypeId::of::<biome_rule_options::no_duplicate_properties::NoDuplicatePropertiesOptions>(),
+    ));
+    result.push(("suspicious", "noDuplicateSelectorsKeyframeBlock", TypeId::of::<biome_rule_options::no_duplicate_selectors_keyframe_block::NoDuplicateSelectorsKeyframeBlockOptions>()));
+    result.push((
+        "suspicious",
+        "noDuplicateTestHooks",
+        TypeId::of::<biome_rule_options::no_duplicate_test_hooks::NoDuplicateTestHooksOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noDuplicateVariableNames",
+        TypeId::of::<
+            biome_rule_options::no_duplicate_variable_names::NoDuplicateVariableNamesOptions,
+        >(),
+    ));
+    result.push(("nursery", "noDuplicatedSpreadProps", TypeId::of::<biome_rule_options::no_duplicated_spread_props::NoDuplicatedSpreadPropsOptions>()));
+    result.push(("performance", "noDynamicNamespaceImportAccess", TypeId::of::<biome_rule_options::no_dynamic_namespace_import_access::NoDynamicNamespaceImportAccessOptions>()));
+    result.push((
+        "suspicious",
+        "noEmptyBlock",
+        TypeId::of::<biome_rule_options::no_empty_block::NoEmptyBlockOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noEmptyBlockStatements",
+        TypeId::of::<biome_rule_options::no_empty_block_statements::NoEmptyBlockStatementsOptions>(
+        ),
+    ));
+    result.push(("correctness", "noEmptyCharacterClassInRegex", TypeId::of::<biome_rule_options::no_empty_character_class_in_regex::NoEmptyCharacterClassInRegexOptions>()));
+    result.push((
+        "suspicious",
+        "noEmptyInterface",
+        TypeId::of::<biome_rule_options::no_empty_interface::NoEmptyInterfaceOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noEmptyObjectKeys",
+        TypeId::of::<biome_rule_options::no_empty_object_keys::NoEmptyObjectKeysOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noEmptyPattern",
+        TypeId::of::<biome_rule_options::no_empty_pattern::NoEmptyPatternOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noEmptySource",
+        TypeId::of::<biome_rule_options::no_empty_source::NoEmptySourceOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noEmptyTypeParameters",
+        TypeId::of::<biome_rule_options::no_empty_type_parameters::NoEmptyTypeParametersOptions>(),
+    ));
+    result.push((
+        "style",
+        "noEnum",
+        TypeId::of::<biome_rule_options::no_enum::NoEnumOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noEqualsToNull",
+        TypeId::of::<biome_rule_options::no_equals_to_null::NoEqualsToNullOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noEvolvingTypes",
+        TypeId::of::<biome_rule_options::no_evolving_types::NoEvolvingTypesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noExcessiveClassesPerFile",
+        TypeId::of::<
+            biome_rule_options::no_excessive_classes_per_file::NoExcessiveClassesPerFileOptions,
+        >(),
+    ));
+    result.push(("complexity", "noExcessiveCognitiveComplexity", TypeId::of::<biome_rule_options::no_excessive_cognitive_complexity::NoExcessiveCognitiveComplexityOptions>()));
+    result.push(("nursery", "noExcessiveLinesPerFile", TypeId::of::<biome_rule_options::no_excessive_lines_per_file::NoExcessiveLinesPerFileOptions>()));
+    result.push((
+        "complexity",
+        "noExcessiveLinesPerFunction",
+        TypeId::of::<
+            biome_rule_options::no_excessive_lines_per_function::NoExcessiveLinesPerFunctionOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "noExcessiveNestedTestSuites",
+        TypeId::of::<
+            biome_rule_options::no_excessive_nested_test_suites::NoExcessiveNestedTestSuitesOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noExplicitAny",
+        TypeId::of::<biome_rule_options::no_explicit_any::NoExplicitAnyOptions>(),
+    ));
+    result.push((
+        "style",
+        "noExportedImports",
+        TypeId::of::<biome_rule_options::no_exported_imports::NoExportedImportsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noExportsInTest",
+        TypeId::of::<biome_rule_options::no_exports_in_test::NoExportsInTestOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noExtraBooleanCast",
+        TypeId::of::<biome_rule_options::no_extra_boolean_cast::NoExtraBooleanCastOptions>(),
+    ));
+    result.push(("suspicious", "noExtraNonNullAssertion", TypeId::of::<biome_rule_options::no_extra_non_null_assertion::NoExtraNonNullAssertionOptions>()));
+    result.push((
+        "suspicious",
+        "noFallthroughSwitchClause",
+        TypeId::of::<
+            biome_rule_options::no_fallthrough_switch_clause::NoFallthroughSwitchClauseOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "noFlatMapIdentity",
+        TypeId::of::<biome_rule_options::no_flat_map_identity::NoFlatMapIdentityOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noFloatingClasses",
+        TypeId::of::<biome_rule_options::no_floating_classes::NoFloatingClassesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noFloatingPromises",
+        TypeId::of::<biome_rule_options::no_floating_promises::NoFloatingPromisesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noFocusedTests",
+        TypeId::of::<biome_rule_options::no_focused_tests::NoFocusedTestsOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noForEach",
+        TypeId::of::<biome_rule_options::no_for_each::NoForEachOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noForIn",
+        TypeId::of::<biome_rule_options::no_for_in::NoForInOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noFunctionAssign",
+        TypeId::of::<biome_rule_options::no_function_assign::NoFunctionAssignOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noGlobalAssign",
+        TypeId::of::<biome_rule_options::no_global_assign::NoGlobalAssignOptions>(),
+    ));
+    result.push(("correctness", "noGlobalDirnameFilename", TypeId::of::<biome_rule_options::no_global_dirname_filename::NoGlobalDirnameFilenameOptions>()));
+    result.push((
+        "security",
+        "noGlobalEval",
+        TypeId::of::<biome_rule_options::no_global_eval::NoGlobalEvalOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noGlobalIsFinite",
+        TypeId::of::<biome_rule_options::no_global_is_finite::NoGlobalIsFiniteOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noGlobalIsNan",
+        TypeId::of::<biome_rule_options::no_global_is_nan::NoGlobalIsNanOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noGlobalObjectCalls",
+        TypeId::of::<biome_rule_options::no_global_object_calls::NoGlobalObjectCallsOptions>(),
+    ));
+    result.push((
+        "style",
+        "noHeadElement",
+        TypeId::of::<biome_rule_options::no_head_element::NoHeadElementOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noHeadImportInDocument",
+        TypeId::of::<biome_rule_options::no_head_import_in_document::NoHeadImportInDocumentOptions>(
+        ),
+    ));
+    result.push((
+        "a11y",
+        "noHeaderScope",
+        TypeId::of::<biome_rule_options::no_header_scope::NoHeaderScopeOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noHexColors",
+        TypeId::of::<biome_rule_options::no_hex_colors::NoHexColorsOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noImgElement",
+        TypeId::of::<biome_rule_options::no_img_element::NoImgElementOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noImplicitAnyLet",
+        TypeId::of::<biome_rule_options::no_implicit_any_let::NoImplicitAnyLetOptions>(),
+    ));
+    result.push((
+        "style",
+        "noImplicitBoolean",
+        TypeId::of::<biome_rule_options::no_implicit_boolean::NoImplicitBooleanOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noImplicitCoercions",
+        TypeId::of::<biome_rule_options::no_implicit_coercions::NoImplicitCoercionsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noImportAssign",
+        TypeId::of::<biome_rule_options::no_import_assign::NoImportAssignOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noImportCycles",
+        TypeId::of::<biome_rule_options::no_import_cycles::NoImportCyclesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noImportantInKeyframe",
+        TypeId::of::<biome_rule_options::no_important_in_keyframe::NoImportantInKeyframeOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noImportantStyles",
+        TypeId::of::<biome_rule_options::no_important_styles::NoImportantStylesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noIncrementDecrement",
+        TypeId::of::<biome_rule_options::no_increment_decrement::NoIncrementDecrementOptions>(),
+    ));
+    result.push((
+        "style",
+        "noInferrableTypes",
+        TypeId::of::<biome_rule_options::no_inferrable_types::NoInferrableTypesOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noInnerDeclarations",
+        TypeId::of::<biome_rule_options::no_inner_declarations::NoInnerDeclarationsOptions>(),
+    ));
+    result.push(("a11y", "noInteractiveElementToNoninteractiveRole", TypeId::of::<biome_rule_options::no_interactive_element_to_noninteractive_role::NoInteractiveElementToNoninteractiveRoleOptions>()));
+    result.push(("correctness", "noInvalidBuiltinInstantiation", TypeId::of::<biome_rule_options::no_invalid_builtin_instantiation::NoInvalidBuiltinInstantiationOptions>()));
+    result.push((
+        "correctness",
+        "noInvalidConstructorSuper",
+        TypeId::of::<
+            biome_rule_options::no_invalid_constructor_super::NoInvalidConstructorSuperOptions,
+        >(),
+    ));
+    result.push(("correctness", "noInvalidDirectionInLinearGradient", TypeId::of::<biome_rule_options::no_invalid_direction_in_linear_gradient::NoInvalidDirectionInLinearGradientOptions>()));
+    result.push((
+        "correctness",
+        "noInvalidGridAreas",
+        TypeId::of::<biome_rule_options::no_invalid_grid_areas::NoInvalidGridAreasOptions>(),
+    ));
+    result.push(("correctness", "noInvalidPositionAtImportRule", TypeId::of::<biome_rule_options::no_invalid_position_at_import_rule::NoInvalidPositionAtImportRuleOptions>()));
+    result.push(("correctness", "noInvalidUseBeforeDeclaration", TypeId::of::<biome_rule_options::no_invalid_use_before_declaration::NoInvalidUseBeforeDeclarationOptions>()));
+    result.push((
+        "suspicious",
+        "noIrregularWhitespace",
+        TypeId::of::<biome_rule_options::no_irregular_whitespace::NoIrregularWhitespaceOptions>(),
+    ));
+    result.push((
+        "style",
+        "noJsxLiterals",
+        TypeId::of::<biome_rule_options::no_jsx_literals::NoJsxLiteralsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noJsxPropsBind",
+        TypeId::of::<biome_rule_options::no_jsx_props_bind::NoJsxPropsBindOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noLabelVar",
+        TypeId::of::<biome_rule_options::no_label_var::NoLabelVarOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "noLabelWithoutControl",
+        TypeId::of::<biome_rule_options::no_label_without_control::NoLabelWithoutControlOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noLeakedRender",
+        TypeId::of::<biome_rule_options::no_leaked_render::NoLeakedRenderOptions>(),
+    ));
+    result.push((
+        "style",
+        "noMagicNumbers",
+        TypeId::of::<biome_rule_options::no_magic_numbers::NoMagicNumbersOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noMisleadingCharacterClass",
+        TypeId::of::<
+            biome_rule_options::no_misleading_character_class::NoMisleadingCharacterClassOptions,
+        >(),
+    ));
+    result.push(("suspicious", "noMisleadingInstantiator", TypeId::of::<biome_rule_options::no_misleading_instantiator::NoMisleadingInstantiatorOptions>()));
+    result.push((
+        "suspicious",
+        "noMisplacedAssertion",
+        TypeId::of::<biome_rule_options::no_misplaced_assertion::NoMisplacedAssertionOptions>(),
+    ));
+    result.push(("suspicious", "noMisrefactoredShorthandAssign", TypeId::of::<biome_rule_options::no_misrefactored_shorthand_assign::NoMisrefactoredShorthandAssignOptions>()));
+    result.push((
+        "correctness",
+        "noMissingVarFunction",
+        TypeId::of::<biome_rule_options::no_missing_var_function::NoMissingVarFunctionOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noMisusedPromises",
+        TypeId::of::<biome_rule_options::no_misused_promises::NoMisusedPromisesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noMultiAssign",
+        TypeId::of::<biome_rule_options::no_multi_assign::NoMultiAssignOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noMultiStr",
+        TypeId::of::<biome_rule_options::no_multi_str::NoMultiStrOptions>(),
+    ));
+    result.push((
+        "style",
+        "noNamespace",
+        TypeId::of::<biome_rule_options::no_namespace::NoNamespaceOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noNamespaceImport",
+        TypeId::of::<biome_rule_options::no_namespace_import::NoNamespaceImportOptions>(),
+    ));
+    result.push((
+        "style",
+        "noNegationElse",
+        TypeId::of::<biome_rule_options::no_negation_else::NoNegationElseOptions>(),
+    ));
+    result.push(("correctness", "noNestedComponentDefinitions", TypeId::of::<biome_rule_options::no_nested_component_definitions::NoNestedComponentDefinitionsOptions>()));
+    result.push((
+        "nursery",
+        "noNestedPromises",
+        TypeId::of::<biome_rule_options::no_nested_promises::NoNestedPromisesOptions>(),
+    ));
+    result.push((
+        "style",
+        "noNestedTernary",
+        TypeId::of::<biome_rule_options::no_nested_ternary::NoNestedTernaryOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noNextAsyncClientComponent",
+        TypeId::of::<
+            biome_rule_options::no_next_async_client_component::NoNextAsyncClientComponentOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noNodejsModules",
+        TypeId::of::<biome_rule_options::no_nodejs_modules::NoNodejsModulesOptions>(),
+    ));
+    result.push(("suspicious", "noNonNullAssertedOptionalChain", TypeId::of::<biome_rule_options::no_non_null_asserted_optional_chain::NoNonNullAssertedOptionalChainOptions>()));
+    result.push((
+        "style",
+        "noNonNullAssertion",
+        TypeId::of::<biome_rule_options::no_non_null_assertion::NoNonNullAssertionOptions>(),
+    ));
+    result.push(("a11y", "noNoninteractiveElementInteractions", TypeId::of::<biome_rule_options::no_noninteractive_element_interactions::NoNoninteractiveElementInteractionsOptions>()));
+    result.push(("a11y", "noNoninteractiveElementToInteractiveRole", TypeId::of::<biome_rule_options::no_noninteractive_element_to_interactive_role::NoNoninteractiveElementToInteractiveRoleOptions>()));
+    result.push(("a11y", "noNoninteractiveTabindex", TypeId::of::<biome_rule_options::no_noninteractive_tabindex::NoNoninteractiveTabindexOptions>()));
+    result.push(("correctness", "noNonoctalDecimalEscape", TypeId::of::<biome_rule_options::no_nonoctal_decimal_escape::NoNonoctalDecimalEscapeOptions>()));
+    result.push((
+        "suspicious",
+        "noOctalEscape",
+        TypeId::of::<biome_rule_options::no_octal_escape::NoOctalEscapeOptions>(),
+    ));
+    result.push((
+        "style",
+        "noParameterAssign",
+        TypeId::of::<biome_rule_options::no_parameter_assign::NoParameterAssignOptions>(),
+    ));
+    result.push((
+        "style",
+        "noParameterProperties",
+        TypeId::of::<biome_rule_options::no_parameter_properties::NoParameterPropertiesOptions>(),
+    ));
+    result.push(("nursery", "noParametersOnlyUsedInRecursion", TypeId::of::<biome_rule_options::no_parameters_only_used_in_recursion::NoParametersOnlyUsedInRecursionOptions>()));
+    result.push((
+        "nursery",
+        "noPlaywrightElementHandle",
+        TypeId::of::<
+            biome_rule_options::no_playwright_element_handle::NoPlaywrightElementHandleOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noPlaywrightEval",
+        TypeId::of::<biome_rule_options::no_playwright_eval::NoPlaywrightEvalOptions>(),
+    ));
+    result.push(("nursery", "noPlaywrightForceOption", TypeId::of::<biome_rule_options::no_playwright_force_option::NoPlaywrightForceOptionOptions>()));
+    result.push((
+        "nursery",
+        "noPlaywrightMissingAwait",
+        TypeId::of::<
+            biome_rule_options::no_playwright_missing_await::NoPlaywrightMissingAwaitOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noPlaywrightNetworkidle",
+        TypeId::of::<biome_rule_options::no_playwright_networkidle::NoPlaywrightNetworkidleOptions>(
+        ),
+    ));
+    result.push((
+        "nursery",
+        "noPlaywrightPagePause",
+        TypeId::of::<biome_rule_options::no_playwright_page_pause::NoPlaywrightPagePauseOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noPlaywrightUselessAwait",
+        TypeId::of::<
+            biome_rule_options::no_playwright_useless_await::NoPlaywrightUselessAwaitOptions,
+        >(),
+    ));
+    result.push(("nursery", "noPlaywrightWaitForNavigation", TypeId::of::<biome_rule_options::no_playwright_wait_for_navigation::NoPlaywrightWaitForNavigationOptions>()));
+    result.push((
+        "nursery",
+        "noPlaywrightWaitForSelector",
+        TypeId::of::<
+            biome_rule_options::no_playwright_wait_for_selector::NoPlaywrightWaitForSelectorOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noPlaywrightWaitForTimeout",
+        TypeId::of::<
+            biome_rule_options::no_playwright_wait_for_timeout::NoPlaywrightWaitForTimeoutOptions,
+        >(),
+    ));
+    result.push((
+        "a11y",
+        "noPositiveTabindex",
+        TypeId::of::<biome_rule_options::no_positive_tabindex::NoPositiveTabindexOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noPrecisionLoss",
+        TypeId::of::<biome_rule_options::no_precision_loss::NoPrecisionLossOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noPrivateImports",
+        TypeId::of::<biome_rule_options::no_private_imports::NoPrivateImportsOptions>(),
+    ));
+    result.push((
+        "style",
+        "noProcessEnv",
+        TypeId::of::<biome_rule_options::no_process_env::NoProcessEnvOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noProcessGlobal",
+        TypeId::of::<biome_rule_options::no_process_global::NoProcessGlobalOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noProto",
+        TypeId::of::<biome_rule_options::no_proto::NoProtoOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noPrototypeBuiltins",
+        TypeId::of::<biome_rule_options::no_prototype_builtins::NoPrototypeBuiltinsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noQuickfixBiome",
+        TypeId::of::<biome_rule_options::no_quickfix_biome::NoQuickfixBiomeOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noQwikUseVisibleTask",
+        TypeId::of::<biome_rule_options::no_qwik_use_visible_task::NoQwikUseVisibleTaskOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noReExportAll",
+        TypeId::of::<biome_rule_options::no_re_export_all::NoReExportAllOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noReactForwardRef",
+        TypeId::of::<biome_rule_options::no_react_forward_ref::NoReactForwardRefOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noReactPropAssignments",
+        TypeId::of::<biome_rule_options::no_react_prop_assignments::NoReactPropAssignmentsOptions>(
+        ),
+    ));
+    result.push((
+        "suspicious",
+        "noReactSpecificProps",
+        TypeId::of::<biome_rule_options::no_react_specific_props::NoReactSpecificPropsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noRedeclare",
+        TypeId::of::<biome_rule_options::no_redeclare::NoRedeclareOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "noRedundantAlt",
+        TypeId::of::<biome_rule_options::no_redundant_alt::NoRedundantAltOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noRedundantDefaultExport",
+        TypeId::of::<
+            biome_rule_options::no_redundant_default_export::NoRedundantDefaultExportOptions,
+        >(),
+    ));
+    result.push((
+        "a11y",
+        "noRedundantRoles",
+        TypeId::of::<biome_rule_options::no_redundant_roles::NoRedundantRolesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noRedundantUseStrict",
+        TypeId::of::<biome_rule_options::no_redundant_use_strict::NoRedundantUseStrictOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noRenderReturnValue",
+        TypeId::of::<biome_rule_options::no_render_return_value::NoRenderReturnValueOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noRestrictedElements",
+        TypeId::of::<biome_rule_options::no_restricted_elements::NoRestrictedElementsOptions>(),
+    ));
+    result.push((
+        "style",
+        "noRestrictedGlobals",
+        TypeId::of::<biome_rule_options::no_restricted_globals::NoRestrictedGlobalsOptions>(),
+    ));
+    result.push((
+        "style",
+        "noRestrictedImports",
+        TypeId::of::<biome_rule_options::no_restricted_imports::NoRestrictedImportsOptions>(),
+    ));
+    result.push((
+        "style",
+        "noRestrictedTypes",
+        TypeId::of::<biome_rule_options::no_restricted_types::NoRestrictedTypesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noReturnAssign",
+        TypeId::of::<biome_rule_options::no_return_assign::NoReturnAssignOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noRootType",
+        TypeId::of::<biome_rule_options::no_root_type::NoRootTypeOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noScriptUrl",
+        TypeId::of::<biome_rule_options::no_script_url::NoScriptUrlOptions>(),
+    ));
+    result.push((
+        "security",
+        "noSecrets",
+        TypeId::of::<biome_rule_options::no_secrets::NoSecretsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noSelfAssign",
+        TypeId::of::<biome_rule_options::no_self_assign::NoSelfAssignOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noSelfCompare",
+        TypeId::of::<biome_rule_options::no_self_compare::NoSelfCompareOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noSetterReturn",
+        TypeId::of::<biome_rule_options::no_setter_return::NoSetterReturnOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noShadow",
+        TypeId::of::<biome_rule_options::no_shadow::NoShadowOptions>(),
+    ));
+    result.push(("suspicious", "noShadowRestrictedNames", TypeId::of::<biome_rule_options::no_shadow_restricted_names::NoShadowRestrictedNamesOptions>()));
+    result.push(("suspicious", "noShorthandPropertyOverrides", TypeId::of::<biome_rule_options::no_shorthand_property_overrides::NoShorthandPropertyOverridesOptions>()));
+    result.push((
+        "style",
+        "noShoutyConstants",
+        TypeId::of::<biome_rule_options::no_shouty_constants::NoShoutyConstantsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noSkippedTests",
+        TypeId::of::<biome_rule_options::no_skipped_tests::NoSkippedTestsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noSolidDestructuredProps",
+        TypeId::of::<
+            biome_rule_options::no_solid_destructured_props::NoSolidDestructuredPropsOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noSparseArray",
+        TypeId::of::<biome_rule_options::no_sparse_array::NoSparseArrayOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "noStaticElementInteractions",
+        TypeId::of::<
+            biome_rule_options::no_static_element_interactions::NoStaticElementInteractionsOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "noStaticOnlyClass",
+        TypeId::of::<biome_rule_options::no_static_only_class::NoStaticOnlyClassOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noStringCaseMismatch",
+        TypeId::of::<biome_rule_options::no_string_case_mismatch::NoStringCaseMismatchOptions>(),
+    ));
+    result.push((
+        "style",
+        "noSubstr",
+        TypeId::of::<biome_rule_options::no_substr::NoSubstrOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noSuspiciousSemicolonInJsx",
+        TypeId::of::<
+            biome_rule_options::no_suspicious_semicolon_in_jsx::NoSuspiciousSemicolonInJsxOptions,
+        >(),
+    ));
+    result.push((
+        "a11y",
+        "noSvgWithoutTitle",
+        TypeId::of::<biome_rule_options::no_svg_without_title::NoSvgWithoutTitleOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noSwitchDeclarations",
+        TypeId::of::<biome_rule_options::no_switch_declarations::NoSwitchDeclarationsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noSyncScripts",
+        TypeId::of::<biome_rule_options::no_sync_scripts::NoSyncScriptsOptions>(),
+    ));
+    result.push(("suspicious", "noTemplateCurlyInString", TypeId::of::<biome_rule_options::no_template_curly_in_string::NoTemplateCurlyInStringOptions>()));
+    result.push((
+        "nursery",
+        "noTernary",
+        TypeId::of::<biome_rule_options::no_ternary::NoTernaryOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noThenProperty",
+        TypeId::of::<biome_rule_options::no_then_property::NoThenPropertyOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noThisInStatic",
+        TypeId::of::<biome_rule_options::no_this_in_static::NoThisInStaticOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noTopLevelLiterals",
+        TypeId::of::<biome_rule_options::no_top_level_literals::NoTopLevelLiteralsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noTsIgnore",
+        TypeId::of::<biome_rule_options::no_ts_ignore::NoTsIgnoreOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noUnassignedVariables",
+        TypeId::of::<biome_rule_options::no_unassigned_variables::NoUnassignedVariablesOptions>(),
+    ));
+    result.push(("correctness", "noUndeclaredDependencies", TypeId::of::<biome_rule_options::no_undeclared_dependencies::NoUndeclaredDependenciesOptions>()));
+    result.push((
+        "nursery",
+        "noUndeclaredEnvVars",
+        TypeId::of::<biome_rule_options::no_undeclared_env_vars::NoUndeclaredEnvVarsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUndeclaredVariables",
+        TypeId::of::<biome_rule_options::no_undeclared_variables::NoUndeclaredVariablesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noUnknownAtRules",
+        TypeId::of::<biome_rule_options::no_unknown_at_rules::NoUnknownAtRulesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noUnknownAttribute",
+        TypeId::of::<biome_rule_options::no_unknown_attribute::NoUnknownAttributeOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownFunction",
+        TypeId::of::<biome_rule_options::no_unknown_function::NoUnknownFunctionOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownMediaFeatureName",
+        TypeId::of::<
+            biome_rule_options::no_unknown_media_feature_name::NoUnknownMediaFeatureNameOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownProperty",
+        TypeId::of::<biome_rule_options::no_unknown_property::NoUnknownPropertyOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownPseudoClass",
+        TypeId::of::<biome_rule_options::no_unknown_pseudo_class::NoUnknownPseudoClassOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownPseudoElement",
+        TypeId::of::<biome_rule_options::no_unknown_pseudo_element::NoUnknownPseudoElementOptions>(
+        ),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownTypeSelector",
+        TypeId::of::<biome_rule_options::no_unknown_type_selector::NoUnknownTypeSelectorOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnknownUnit",
+        TypeId::of::<biome_rule_options::no_unknown_unit::NoUnknownUnitOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnmatchableAnbSelector",
+        TypeId::of::<
+            biome_rule_options::no_unmatchable_anb_selector::NoUnmatchableAnbSelectorOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "noUnnecessaryConditions",
+        TypeId::of::<biome_rule_options::no_unnecessary_conditions::NoUnnecessaryConditionsOptions>(
+        ),
+    ));
+    result.push((
+        "correctness",
+        "noUnreachable",
+        TypeId::of::<biome_rule_options::no_unreachable::NoUnreachableOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnreachableSuper",
+        TypeId::of::<biome_rule_options::no_unreachable_super::NoUnreachableSuperOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnresolvedImports",
+        TypeId::of::<biome_rule_options::no_unresolved_imports::NoUnresolvedImportsOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noUnsafeDeclarationMerging",
+        TypeId::of::<
+            biome_rule_options::no_unsafe_declaration_merging::NoUnsafeDeclarationMergingOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noUnsafeFinally",
+        TypeId::of::<biome_rule_options::no_unsafe_finally::NoUnsafeFinallyOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noUnsafeNegation",
+        TypeId::of::<biome_rule_options::no_unsafe_negation::NoUnsafeNegationOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnsafeOptionalChaining",
+        TypeId::of::<
+            biome_rule_options::no_unsafe_optional_chaining::NoUnsafeOptionalChainingOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "noUnusedExpressions",
+        TypeId::of::<biome_rule_options::no_unused_expressions::NoUnusedExpressionsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnusedFunctionParameters",
+        TypeId::of::<
+            biome_rule_options::no_unused_function_parameters::NoUnusedFunctionParametersOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noUnusedImports",
+        TypeId::of::<biome_rule_options::no_unused_imports::NoUnusedImportsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnusedLabels",
+        TypeId::of::<biome_rule_options::no_unused_labels::NoUnusedLabelsOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noUnusedPrivateClassMembers",
+        TypeId::of::<
+            biome_rule_options::no_unused_private_class_members::NoUnusedPrivateClassMembersOptions,
+        >(),
+    ));
+    result.push(("style", "noUnusedTemplateLiteral", TypeId::of::<biome_rule_options::no_unused_template_literal::NoUnusedTemplateLiteralOptions>()));
+    result.push((
+        "correctness",
+        "noUnusedVariables",
+        TypeId::of::<biome_rule_options::no_unused_variables::NoUnusedVariablesOptions>(),
+    ));
+    result.push((
+        "performance",
+        "noUnwantedPolyfillio",
+        TypeId::of::<biome_rule_options::no_unwanted_polyfillio::NoUnwantedPolyfillioOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessCatch",
+        TypeId::of::<biome_rule_options::no_useless_catch::NoUselessCatchOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessCatchBinding",
+        TypeId::of::<biome_rule_options::no_useless_catch_binding::NoUselessCatchBindingOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessConstructor",
+        TypeId::of::<biome_rule_options::no_useless_constructor::NoUselessConstructorOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessContinue",
+        TypeId::of::<biome_rule_options::no_useless_continue::NoUselessContinueOptions>(),
+    ));
+    result.push((
+        "style",
+        "noUselessElse",
+        TypeId::of::<biome_rule_options::no_useless_else::NoUselessElseOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessEmptyExport",
+        TypeId::of::<biome_rule_options::no_useless_empty_export::NoUselessEmptyExportOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessEscapeInRegex",
+        TypeId::of::<biome_rule_options::no_useless_escape_in_regex::NoUselessEscapeInRegexOptions>(
+        ),
+    ));
+    result.push(("suspicious", "noUselessEscapeInString", TypeId::of::<biome_rule_options::no_useless_escape_in_string::NoUselessEscapeInStringOptions>()));
+    result.push((
+        "complexity",
+        "noUselessFragments",
+        TypeId::of::<biome_rule_options::no_useless_fragments::NoUselessFragmentsOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessLabel",
+        TypeId::of::<biome_rule_options::no_useless_label::NoUselessLabelOptions>(),
+    ));
+    result.push(("complexity", "noUselessLoneBlockStatements", TypeId::of::<biome_rule_options::no_useless_lone_block_statements::NoUselessLoneBlockStatementsOptions>()));
+    result.push((
+        "suspicious",
+        "noUselessRegexBackrefs",
+        TypeId::of::<biome_rule_options::no_useless_regex_backrefs::NoUselessRegexBackrefsOptions>(
+        ),
+    ));
+    result.push((
+        "complexity",
+        "noUselessRename",
+        TypeId::of::<biome_rule_options::no_useless_rename::NoUselessRenameOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noUselessReturn",
+        TypeId::of::<biome_rule_options::no_useless_return::NoUselessReturnOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessStringConcat",
+        TypeId::of::<biome_rule_options::no_useless_string_concat::NoUselessStringConcatOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessStringRaw",
+        TypeId::of::<biome_rule_options::no_useless_string_raw::NoUselessStringRawOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessSwitchCase",
+        TypeId::of::<biome_rule_options::no_useless_switch_case::NoUselessSwitchCaseOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessTernary",
+        TypeId::of::<biome_rule_options::no_useless_ternary::NoUselessTernaryOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noUselessThisAlias",
+        TypeId::of::<biome_rule_options::no_useless_this_alias::NoUselessThisAliasOptions>(),
+    ));
+    result.push(("complexity", "noUselessTypeConstraint", TypeId::of::<biome_rule_options::no_useless_type_constraint::NoUselessTypeConstraintOptions>()));
+    result.push((
+        "complexity",
+        "noUselessUndefined",
+        TypeId::of::<biome_rule_options::no_useless_undefined::NoUselessUndefinedOptions>(),
+    ));
+    result.push(("complexity", "noUselessUndefinedInitialization", TypeId::of::<biome_rule_options::no_useless_undefined_initialization::NoUselessUndefinedInitializationOptions>()));
+    result.push((
+        "style",
+        "noValueAtRule",
+        TypeId::of::<biome_rule_options::no_value_at_rule::NoValueAtRuleOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noVar",
+        TypeId::of::<biome_rule_options::no_var::NoVarOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "noVoid",
+        TypeId::of::<biome_rule_options::no_void::NoVoidOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noVoidElementsWithChildren",
+        TypeId::of::<
+            biome_rule_options::no_void_elements_with_children::NoVoidElementsWithChildrenOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noVoidTypeReturn",
+        TypeId::of::<biome_rule_options::no_void_type_return::NoVoidTypeReturnOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noVueArrowFuncInWatch",
+        TypeId::of::<biome_rule_options::no_vue_arrow_func_in_watch::NoVueArrowFuncInWatchOptions>(
+        ),
+    ));
+    result.push((
+        "correctness",
+        "noVueDataObjectDeclaration",
+        TypeId::of::<
+            biome_rule_options::no_vue_data_object_declaration::NoVueDataObjectDeclarationOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "noVueDuplicateKeys",
+        TypeId::of::<biome_rule_options::no_vue_duplicate_keys::NoVueDuplicateKeysOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noVueOptionsApi",
+        TypeId::of::<biome_rule_options::no_vue_options_api::NoVueOptionsApiOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "noVueRefAsOperand",
+        TypeId::of::<biome_rule_options::no_vue_ref_as_operand::NoVueRefAsOperandOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noVueReservedKeys",
+        TypeId::of::<biome_rule_options::no_vue_reserved_keys::NoVueReservedKeysOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "noVueReservedProps",
+        TypeId::of::<biome_rule_options::no_vue_reserved_props::NoVueReservedPropsOptions>(),
+    ));
+    result.push(("correctness", "noVueSetupPropsReactivityLoss", TypeId::of::<biome_rule_options::no_vue_setup_props_reactivity_loss::NoVueSetupPropsReactivityLossOptions>()));
+    result.push((
+        "nursery",
+        "noVueVIfWithVFor",
+        TypeId::of::<biome_rule_options::no_vue_v_if_with_v_for::NoVueVIfWithVForOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "noWith",
+        TypeId::of::<biome_rule_options::no_with::NoWithOptions>(),
+    ));
+    result.push((
+        "style",
+        "noYodaExpression",
+        TypeId::of::<biome_rule_options::no_yoda_expression::NoYodaExpressionOptions>(),
+    ));
+    result.push(("suspicious", "useAdjacentOverloadSignatures", TypeId::of::<biome_rule_options::use_adjacent_overload_signatures::UseAdjacentOverloadSignaturesOptions>()));
+    result.push((
+        "a11y",
+        "useAltText",
+        TypeId::of::<biome_rule_options::use_alt_text::UseAltTextOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useAnchorContent",
+        TypeId::of::<biome_rule_options::use_anchor_content::UseAnchorContentOptions>(),
+    ));
+    result.push(("a11y", "useAriaActivedescendantWithTabindex", TypeId::of::<biome_rule_options::use_aria_activedescendant_with_tabindex::UseAriaActivedescendantWithTabindexOptions>()));
+    result.push((
+        "a11y",
+        "useAriaPropsForRole",
+        TypeId::of::<biome_rule_options::use_aria_props_for_role::UseAriaPropsForRoleOptions>(),
+    ));
+    result.push(("a11y", "useAriaPropsSupportedByRole", TypeId::of::<biome_rule_options::use_aria_props_supported_by_role::UseAriaPropsSupportedByRoleOptions>()));
+    result.push((
+        "style",
+        "useArrayLiterals",
+        TypeId::of::<biome_rule_options::use_array_literals::UseArrayLiteralsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useArraySome",
+        TypeId::of::<biome_rule_options::use_array_some::UseArraySomeOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useArraySortCompare",
+        TypeId::of::<biome_rule_options::use_array_sort_compare::UseArraySortCompareOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useArrowFunction",
+        TypeId::of::<biome_rule_options::use_arrow_function::UseArrowFunctionOptions>(),
+    ));
+    result.push((
+        "style",
+        "useAsConstAssertion",
+        TypeId::of::<biome_rule_options::use_as_const_assertion::UseAsConstAssertionOptions>(),
+    ));
+    result.push((
+        "style",
+        "useAtIndex",
+        TypeId::of::<biome_rule_options::use_at_index::UseAtIndexOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useAwait",
+        TypeId::of::<biome_rule_options::use_await::UseAwaitOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useAwaitThenable",
+        TypeId::of::<biome_rule_options::use_await_thenable::UseAwaitThenableOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useBaseline",
+        TypeId::of::<biome_rule_options::use_baseline::UseBaselineOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useBiomeIgnoreFolder",
+        TypeId::of::<biome_rule_options::use_biome_ignore_folder::UseBiomeIgnoreFolderOptions>(),
+    ));
+    result.push((
+        "style",
+        "useBlockStatements",
+        TypeId::of::<biome_rule_options::use_block_statements::UseBlockStatementsOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useButtonType",
+        TypeId::of::<biome_rule_options::use_button_type::UseButtonTypeOptions>(),
+    ));
+    result.push((
+        "style",
+        "useCollapsedElseIf",
+        TypeId::of::<biome_rule_options::use_collapsed_else_if::UseCollapsedElseIfOptions>(),
+    ));
+    result.push((
+        "style",
+        "useCollapsedIf",
+        TypeId::of::<biome_rule_options::use_collapsed_if::UseCollapsedIfOptions>(),
+    ));
+    result.push(("style", "useComponentExportOnlyModules", TypeId::of::<biome_rule_options::use_component_export_only_modules::UseComponentExportOnlyModulesOptions>()));
+    result.push((
+        "style",
+        "useConsistentArrayType",
+        TypeId::of::<biome_rule_options::use_consistent_array_type::UseConsistentArrayTypeOptions>(
+        ),
+    ));
+    result.push((
+        "style",
+        "useConsistentArrowReturn",
+        TypeId::of::<
+            biome_rule_options::use_consistent_arrow_return::UseConsistentArrowReturnOptions,
+        >(),
+    ));
+    result.push(("style", "useConsistentBuiltinInstantiation", TypeId::of::<biome_rule_options::use_consistent_builtin_instantiation::UseConsistentBuiltinInstantiationOptions>()));
+    result.push((
+        "style",
+        "useConsistentCurlyBraces",
+        TypeId::of::<
+            biome_rule_options::use_consistent_curly_braces::UseConsistentCurlyBracesOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "useConsistentEnumValueType",
+        TypeId::of::<
+            biome_rule_options::use_consistent_enum_value_type::UseConsistentEnumValueTypeOptions,
+        >(),
+    ));
+    result.push(("nursery", "useConsistentGraphqlDescriptions", TypeId::of::<biome_rule_options::use_consistent_graphql_descriptions::UseConsistentGraphqlDescriptionsOptions>()));
+    result.push(("style", "useConsistentMemberAccessibility", TypeId::of::<biome_rule_options::use_consistent_member_accessibility::UseConsistentMemberAccessibilityOptions>()));
+    result.push(("nursery", "useConsistentMethodSignatures", TypeId::of::<biome_rule_options::use_consistent_method_signatures::UseConsistentMethodSignaturesOptions>()));
+    result.push(("style", "useConsistentObjectDefinitions", TypeId::of::<biome_rule_options::use_consistent_object_definitions::UseConsistentObjectDefinitionsOptions>()));
+    result.push(("style", "useConsistentTypeDefinitions", TypeId::of::<biome_rule_options::use_consistent_type_definitions::UseConsistentTypeDefinitionsOptions>()));
+    result.push((
+        "style",
+        "useConst",
+        TypeId::of::<biome_rule_options::use_const::UseConstOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useDateNow",
+        TypeId::of::<biome_rule_options::use_date_now::UseDateNowOptions>(),
+    ));
+    result.push(("style", "useDefaultParameterLast", TypeId::of::<biome_rule_options::use_default_parameter_last::UseDefaultParameterLastOptions>()));
+    result.push((
+        "style",
+        "useDefaultSwitchClause",
+        TypeId::of::<biome_rule_options::use_default_switch_clause::UseDefaultSwitchClauseOptions>(
+        ),
+    ));
+    result.push((
+        "suspicious",
+        "useDefaultSwitchClauseLast",
+        TypeId::of::<
+            biome_rule_options::use_default_switch_clause_last::UseDefaultSwitchClauseLastOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "useDeprecatedDate",
+        TypeId::of::<biome_rule_options::use_deprecated_date::UseDeprecatedDateOptions>(),
+    ));
+    result.push((
+        "style",
+        "useDeprecatedReason",
+        TypeId::of::<biome_rule_options::use_deprecated_reason::UseDeprecatedReasonOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useDestructuring",
+        TypeId::of::<biome_rule_options::use_destructuring::UseDestructuringOptions>(),
+    ));
+    result.push((
+        "style",
+        "useEnumInitializers",
+        TypeId::of::<biome_rule_options::use_enum_initializers::UseEnumInitializersOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useErrorCause",
+        TypeId::of::<biome_rule_options::use_error_cause::UseErrorCauseOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useErrorMessage",
+        TypeId::of::<biome_rule_options::use_error_message::UseErrorMessageOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useExhaustiveDependencies",
+        TypeId::of::<
+            biome_rule_options::use_exhaustive_dependencies::UseExhaustiveDependenciesOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "useExhaustiveSwitchCases",
+        TypeId::of::<
+            biome_rule_options::use_exhaustive_switch_cases::UseExhaustiveSwitchCasesOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "useExpect",
+        TypeId::of::<biome_rule_options::use_expect::UseExpectOptions>(),
+    ));
+    result.push((
+        "style",
+        "useExplicitLengthCheck",
+        TypeId::of::<biome_rule_options::use_explicit_length_check::UseExplicitLengthCheckOptions>(
+        ),
+    ));
+    result.push((
+        "nursery",
+        "useExplicitType",
+        TypeId::of::<biome_rule_options::use_explicit_type::UseExplicitTypeOptions>(),
+    ));
+    result.push((
+        "style",
+        "useExponentiationOperator",
+        TypeId::of::<
+            biome_rule_options::use_exponentiation_operator::UseExponentiationOperatorOptions,
+        >(),
+    ));
+    result.push((
+        "style",
+        "useExportType",
+        TypeId::of::<biome_rule_options::use_export_type::UseExportTypeOptions>(),
+    ));
+    result.push((
+        "style",
+        "useExportsLast",
+        TypeId::of::<biome_rule_options::use_exports_last::UseExportsLastOptions>(),
+    ));
+    result.push((
+        "style",
+        "useFilenamingConvention",
+        TypeId::of::<biome_rule_options::use_filenaming_convention::UseFilenamingConventionOptions>(
+        ),
+    ));
+    result.push((
+        "nursery",
+        "useFind",
+        TypeId::of::<biome_rule_options::use_find::UseFindOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useFlatMap",
+        TypeId::of::<biome_rule_options::use_flat_map::UseFlatMapOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useFocusableInteractive",
+        TypeId::of::<biome_rule_options::use_focusable_interactive::UseFocusableInteractiveOptions>(
+        ),
+    ));
+    result.push((
+        "style",
+        "useForOf",
+        TypeId::of::<biome_rule_options::use_for_of::UseForOfOptions>(),
+    ));
+    result.push((
+        "style",
+        "useFragmentSyntax",
+        TypeId::of::<biome_rule_options::use_fragment_syntax::UseFragmentSyntaxOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useGenericFontNames",
+        TypeId::of::<biome_rule_options::use_generic_font_names::UseGenericFontNamesOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useGetterReturn",
+        TypeId::of::<biome_rule_options::use_getter_return::UseGetterReturnOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useGlobalThis",
+        TypeId::of::<biome_rule_options::use_global_this::UseGlobalThisOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useGoogleFontDisplay",
+        TypeId::of::<biome_rule_options::use_google_font_display::UseGoogleFontDisplayOptions>(),
+    ));
+    result.push(("performance", "useGoogleFontPreconnect", TypeId::of::<biome_rule_options::use_google_font_preconnect::UseGoogleFontPreconnectOptions>()));
+    result.push((
+        "correctness",
+        "useGraphqlNamedOperations",
+        TypeId::of::<
+            biome_rule_options::use_graphql_named_operations::UseGraphqlNamedOperationsOptions,
+        >(),
+    ));
+    result.push((
+        "style",
+        "useGraphqlNamingConvention",
+        TypeId::of::<
+            biome_rule_options::use_graphql_naming_convention::UseGraphqlNamingConventionOptions,
+        >(),
+    ));
+    result.push(("style", "useGroupedAccessorPairs", TypeId::of::<biome_rule_options::use_grouped_accessor_pairs::UseGroupedAccessorPairsOptions>()));
+    result.push((
+        "suspicious",
+        "useGuardForIn",
+        TypeId::of::<biome_rule_options::use_guard_for_in::UseGuardForInOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useHeadingContent",
+        TypeId::of::<biome_rule_options::use_heading_content::UseHeadingContentOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useHookAtTopLevel",
+        TypeId::of::<biome_rule_options::use_hook_at_top_level::UseHookAtTopLevelOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useHtmlLang",
+        TypeId::of::<biome_rule_options::use_html_lang::UseHtmlLangOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useIframeTitle",
+        TypeId::of::<biome_rule_options::use_iframe_title::UseIframeTitleOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useImageSize",
+        TypeId::of::<biome_rule_options::use_image_size::UseImageSizeOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useImportExtensions",
+        TypeId::of::<biome_rule_options::use_import_extensions::UseImportExtensionsOptions>(),
+    ));
+    result.push((
+        "style",
+        "useImportType",
+        TypeId::of::<biome_rule_options::use_import_type::UseImportTypeOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useImportsFirst",
+        TypeId::of::<biome_rule_options::use_imports_first::UseImportsFirstOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useIndexOf",
+        TypeId::of::<biome_rule_options::use_index_of::UseIndexOfOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useInlineScriptId",
+        TypeId::of::<biome_rule_options::use_inline_script_id::UseInlineScriptIdOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useInputName",
+        TypeId::of::<biome_rule_options::use_input_name::UseInputNameOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useIsArray",
+        TypeId::of::<biome_rule_options::use_is_array::UseIsArrayOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useIsNan",
+        TypeId::of::<biome_rule_options::use_is_nan::UseIsNanOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useIterableCallbackReturn",
+        TypeId::of::<
+            biome_rule_options::use_iterable_callback_return::UseIterableCallbackReturnOptions,
+        >(),
+    ));
+    result.push(("correctness", "useJsonImportAttributes", TypeId::of::<biome_rule_options::use_json_import_attributes::UseJsonImportAttributesOptions>()));
+    result.push((
+        "correctness",
+        "useJsxKeyInIterable",
+        TypeId::of::<biome_rule_options::use_jsx_key_in_iterable::UseJsxKeyInIterableOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useKeyWithClickEvents",
+        TypeId::of::<biome_rule_options::use_key_with_click_events::UseKeyWithClickEventsOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useKeyWithMouseEvents",
+        TypeId::of::<biome_rule_options::use_key_with_mouse_events::UseKeyWithMouseEventsOptions>(),
+    ));
+    result.push((
+        "style",
+        "useLiteralEnumMembers",
+        TypeId::of::<biome_rule_options::use_literal_enum_members::UseLiteralEnumMembersOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useLiteralKeys",
+        TypeId::of::<biome_rule_options::use_literal_keys::UseLiteralKeysOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useLoneAnonymousOperation",
+        TypeId::of::<
+            biome_rule_options::use_lone_anonymous_operation::UseLoneAnonymousOperationOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "useLoneExecutableDefinition",
+        TypeId::of::<
+            biome_rule_options::use_lone_executable_definition::UseLoneExecutableDefinitionOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "useMaxParams",
+        TypeId::of::<biome_rule_options::use_max_params::UseMaxParamsOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useMediaCaption",
+        TypeId::of::<biome_rule_options::use_media_caption::UseMediaCaptionOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useNamedCaptureGroup",
+        TypeId::of::<biome_rule_options::use_named_capture_group::UseNamedCaptureGroupOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useNamespaceKeyword",
+        TypeId::of::<biome_rule_options::use_namespace_keyword::UseNamespaceKeywordOptions>(),
+    ));
+    result.push((
+        "style",
+        "useNamingConvention",
+        TypeId::of::<biome_rule_options::use_naming_convention::UseNamingConventionOptions>(),
+    ));
+    result.push((
+        "style",
+        "useNodeAssertStrict",
+        TypeId::of::<biome_rule_options::use_node_assert_strict::UseNodeAssertStrictOptions>(),
+    ));
+    result.push(("style", "useNodejsImportProtocol", TypeId::of::<biome_rule_options::use_nodejs_import_protocol::UseNodejsImportProtocolOptions>()));
+    result.push((
+        "nursery",
+        "useNullishCoalescing",
+        TypeId::of::<biome_rule_options::use_nullish_coalescing::UseNullishCoalescingOptions>(),
+    ));
+    result.push((
+        "style",
+        "useNumberNamespace",
+        TypeId::of::<biome_rule_options::use_number_namespace::UseNumberNamespaceOptions>(),
+    ));
+    result.push(("suspicious", "useNumberToFixedDigitsArgument", TypeId::of::<biome_rule_options::use_number_to_fixed_digits_argument::UseNumberToFixedDigitsArgumentOptions>()));
+    result.push((
+        "complexity",
+        "useNumericLiterals",
+        TypeId::of::<biome_rule_options::use_numeric_literals::UseNumericLiteralsOptions>(),
+    ));
+    result.push((
+        "style",
+        "useNumericSeparators",
+        TypeId::of::<biome_rule_options::use_numeric_separators::UseNumericSeparatorsOptions>(),
+    ));
+    result.push((
+        "style",
+        "useObjectSpread",
+        TypeId::of::<biome_rule_options::use_object_spread::UseObjectSpreadOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useOptionalChain",
+        TypeId::of::<biome_rule_options::use_optional_chain::UseOptionalChainOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useParseIntRadix",
+        TypeId::of::<biome_rule_options::use_parse_int_radix::UseParseIntRadixOptions>(),
+    ));
+    result.push(("nursery", "usePlaywrightValidDescribeCallback", TypeId::of::<biome_rule_options::use_playwright_valid_describe_callback::UsePlaywrightValidDescribeCallbackOptions>()));
+    result.push((
+        "correctness",
+        "useQwikClasslist",
+        TypeId::of::<biome_rule_options::use_qwik_classlist::UseQwikClasslistOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useQwikMethodUsage",
+        TypeId::of::<biome_rule_options::use_qwik_method_usage::UseQwikMethodUsageOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useQwikValidLexicalScope",
+        TypeId::of::<
+            biome_rule_options::use_qwik_valid_lexical_scope::UseQwikValidLexicalScopeOptions,
+        >(),
+    ));
+    result.push((
+        "style",
+        "useReactFunctionComponents",
+        TypeId::of::<
+            biome_rule_options::use_react_function_components::UseReactFunctionComponentsOptions,
+        >(),
+    ));
+    result.push((
+        "style",
+        "useReadonlyClassProperties",
+        TypeId::of::<
+            biome_rule_options::use_readonly_class_properties::UseReadonlyClassPropertiesOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "useRegexLiterals",
+        TypeId::of::<biome_rule_options::use_regex_literals::UseRegexLiteralsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useRegexpExec",
+        TypeId::of::<biome_rule_options::use_regexp_exec::UseRegexpExecOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useRequiredScripts",
+        TypeId::of::<biome_rule_options::use_required_scripts::UseRequiredScriptsOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useScopedStyles",
+        TypeId::of::<biome_rule_options::use_scoped_styles::UseScopedStylesOptions>(),
+    ));
+    result.push((
+        "style",
+        "useSelfClosingElements",
+        TypeId::of::<biome_rule_options::use_self_closing_elements::UseSelfClosingElementsOptions>(
+        ),
+    ));
+    result.push((
+        "a11y",
+        "useSemanticElements",
+        TypeId::of::<biome_rule_options::use_semantic_elements::UseSemanticElementsOptions>(),
+    ));
+    result.push((
+        "style",
+        "useShorthandAssign",
+        TypeId::of::<biome_rule_options::use_shorthand_assign::UseShorthandAssignOptions>(),
+    ));
+    result.push((
+        "style",
+        "useShorthandFunctionType",
+        TypeId::of::<
+            biome_rule_options::use_shorthand_function_type::UseShorthandFunctionTypeOptions,
+        >(),
+    ));
+    result.push((
+        "complexity",
+        "useSimpleNumberKeys",
+        TypeId::of::<biome_rule_options::use_simple_number_keys::UseSimpleNumberKeysOptions>(),
+    ));
+    result.push(("complexity", "useSimplifiedLogicExpression", TypeId::of::<biome_rule_options::use_simplified_logic_expression::UseSimplifiedLogicExpressionOptions>()));
+    result.push((
+        "correctness",
+        "useSingleJsDocAsterisk",
+        TypeId::of::<biome_rule_options::use_single_js_doc_asterisk::UseSingleJsDocAsteriskOptions>(
+        ),
+    ));
+    result.push((
+        "style",
+        "useSingleVarDeclarator",
+        TypeId::of::<biome_rule_options::use_single_var_declarator::UseSingleVarDeclaratorOptions>(
+        ),
+    ));
+    result.push((
+        "performance",
+        "useSolidForComponent",
+        TypeId::of::<biome_rule_options::use_solid_for_component::UseSolidForComponentOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useSortedClasses",
+        TypeId::of::<biome_rule_options::use_sorted_classes::UseSortedClassesOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useSpread",
+        TypeId::of::<biome_rule_options::use_spread::UseSpreadOptions>(),
+    ));
+    result.push((
+        "suspicious",
+        "useStaticResponseMethods",
+        TypeId::of::<
+            biome_rule_options::use_static_response_methods::UseStaticResponseMethodsOptions,
+        >(),
+    ));
+    result.push((
+        "suspicious",
+        "useStrictMode",
+        TypeId::of::<biome_rule_options::use_strict_mode::UseStrictModeOptions>(),
+    ));
+    result.push((
+        "style",
+        "useSymbolDescription",
+        TypeId::of::<biome_rule_options::use_symbol_description::UseSymbolDescriptionOptions>(),
+    ));
+    result.push((
+        "style",
+        "useTemplate",
+        TypeId::of::<biome_rule_options::use_template::UseTemplateOptions>(),
+    ));
+    result.push((
+        "style",
+        "useThrowNewError",
+        TypeId::of::<biome_rule_options::use_throw_new_error::UseThrowNewErrorOptions>(),
+    ));
+    result.push((
+        "style",
+        "useThrowOnlyError",
+        TypeId::of::<biome_rule_options::use_throw_only_error::UseThrowOnlyErrorOptions>(),
+    ));
+    result.push((
+        "performance",
+        "useTopLevelRegex",
+        TypeId::of::<biome_rule_options::use_top_level_regex::UseTopLevelRegexOptions>(),
+    ));
+    result.push((
+        "style",
+        "useTrimStartEnd",
+        TypeId::of::<biome_rule_options::use_trim_start_end::UseTrimStartEndOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useUnicodeRegex",
+        TypeId::of::<biome_rule_options::use_unicode_regex::UseUnicodeRegexOptions>(),
+    ));
+    result.push((
+        "style",
+        "useUnifiedTypeSignatures",
+        TypeId::of::<
+            biome_rule_options::use_unified_type_signatures::UseUnifiedTypeSignaturesOptions,
+        >(),
+    ));
+    result.push((
+        "correctness",
+        "useUniqueElementIds",
+        TypeId::of::<biome_rule_options::use_unique_element_ids::UseUniqueElementIdsOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidAnchor",
+        TypeId::of::<biome_rule_options::use_valid_anchor::UseValidAnchorOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidAriaProps",
+        TypeId::of::<biome_rule_options::use_valid_aria_props::UseValidAriaPropsOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidAriaRole",
+        TypeId::of::<biome_rule_options::use_valid_aria_role::UseValidAriaRoleOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidAriaValues",
+        TypeId::of::<biome_rule_options::use_valid_aria_values::UseValidAriaValuesOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidAutocomplete",
+        TypeId::of::<biome_rule_options::use_valid_autocomplete::UseValidAutocompleteOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useValidForDirection",
+        TypeId::of::<biome_rule_options::use_valid_for_direction::UseValidForDirectionOptions>(),
+    ));
+    result.push((
+        "a11y",
+        "useValidLang",
+        TypeId::of::<biome_rule_options::use_valid_lang::UseValidLangOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useValidTypeof",
+        TypeId::of::<biome_rule_options::use_valid_typeof::UseValidTypeofOptions>(),
+    ));
+    result.push(("nursery", "useVueConsistentDefinePropsDeclaration", TypeId::of::<biome_rule_options::use_vue_consistent_define_props_declaration::UseVueConsistentDefinePropsDeclarationOptions>()));
+    result.push((
+        "nursery",
+        "useVueConsistentVBindStyle",
+        TypeId::of::<
+            biome_rule_options::use_vue_consistent_v_bind_style::UseVueConsistentVBindStyleOptions,
+        >(),
+    ));
+    result.push((
+        "nursery",
+        "useVueConsistentVOnStyle",
+        TypeId::of::<
+            biome_rule_options::use_vue_consistent_v_on_style::UseVueConsistentVOnStyleOptions,
+        >(),
+    ));
+    result.push(("nursery", "useVueDefineMacrosOrder", TypeId::of::<biome_rule_options::use_vue_define_macros_order::UseVueDefineMacrosOrderOptions>()));
+    result.push((
+        "nursery",
+        "useVueHyphenatedAttributes",
+        TypeId::of::<
+            biome_rule_options::use_vue_hyphenated_attributes::UseVueHyphenatedAttributesOptions,
+        >(),
+    ));
+    result.push(("nursery", "useVueMultiWordComponentNames", TypeId::of::<biome_rule_options::use_vue_multi_word_component_names::UseVueMultiWordComponentNamesOptions>()));
+    result.push((
+        "nursery",
+        "useVueVForKey",
+        TypeId::of::<biome_rule_options::use_vue_v_for_key::UseVueVForKeyOptions>(),
+    ));
+    result.push(("nursery", "useVueValidTemplateRoot", TypeId::of::<biome_rule_options::use_vue_valid_template_root::UseVueValidTemplateRootOptions>()));
+    result.push((
+        "nursery",
+        "useVueValidVBind",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_bind::UseVueValidVBindOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVCloak",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_cloak::UseVueValidVCloakOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVElse",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_else::UseVueValidVElseOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVElseIf",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_else_if::UseVueValidVElseIfOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVHtml",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_html::UseVueValidVHtmlOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVIf",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_if::UseVueValidVIfOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVOn",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_on::UseVueValidVOnOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVOnce",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_once::UseVueValidVOnceOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVPre",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_pre::UseVueValidVPreOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueValidVText",
+        TypeId::of::<biome_rule_options::use_vue_valid_v_text::UseVueValidVTextOptions>(),
+    ));
+    result.push((
+        "nursery",
+        "useVueVapor",
+        TypeId::of::<biome_rule_options::use_vue_vapor::UseVueVaporOptions>(),
+    ));
+    result.push((
+        "complexity",
+        "useWhile",
+        TypeId::of::<biome_rule_options::use_while::UseWhileOptions>(),
+    ));
+    result.push((
+        "correctness",
+        "useYield",
+        TypeId::of::<biome_rule_options::use_yield::UseYieldOptions>(),
+    ));
+    result
+}
diff --git a/crates/biome_html_analyze/src/lint/a11y/use_aria_props_for_role.rs b/crates/biome_html_analyze/src/lint/a11y/use_aria_props_for_role.rs
index ead9b61d881a..54c6cfc4362b 100644
--- a/crates/biome_html_analyze/src/lint/a11y/use_aria_props_for_role.rs
+++ b/crates/biome_html_analyze/src/lint/a11y/use_aria_props_for_role.rs
@@ -6,7 +6,7 @@ use biome_console::markup;
 use biome_diagnostics::Severity;
 use biome_html_syntax::{AnyHtmlElement, HtmlAttribute};
 use biome_rowan::{AstNode, Text};
-use biome_rule_options::use_aria_props_supported_by_role::UseAriaPropsSupportedByRoleOptions;
+use biome_rule_options::use_aria_props_for_role::UseAriaPropsForRoleOptions;
 
 declare_lint_rule! {
     /// Enforce that elements with ARIA roles must have all required ARIA attributes for that role.
@@ -64,7 +64,7 @@ impl Rule for UseAriaPropsForRole {
     type Query = Ast<AnyHtmlElement>;
     type State = UseAriaPropsForRoleState;
     type Signals = Option<Self::State>;
-    type Options = UseAriaPropsSupportedByRoleOptions;
+    type Options = UseAriaPropsForRoleOptions;
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let node = ctx.query();
diff --git a/crates/biome_service/Cargo.toml b/crates/biome_service/Cargo.toml
index f8d823184694..da6d7e644097 100644
--- a/crates/biome_service/Cargo.toml
+++ b/crates/biome_service/Cargo.toml
@@ -86,7 +86,8 @@ tracing                  = { workspace = true, features = ["attributes", "log"]
 web-time                 = { workspace = true }
 
 [dev-dependencies]
-insta = { workspace = true }
+biome_configuration = { workspace = true, features = ["test-utils"] }
+insta               = { workspace = true }
 
 [features]
 js_plugin = ["biome_plugin_loader/js_plugin"]
diff --git a/crates/biome_service/src/configuration.rs b/crates/biome_service/src/configuration.rs
index cccad909cfc6..da44d3af6076 100644
--- a/crates/biome_service/src/configuration.rs
+++ b/crates/biome_service/src/configuration.rs
@@ -1148,3 +1148,138 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod configuration_harness {
+    use biome_analyze::{GroupCategory, Queryable, RegistryVisitor, Rule, RuleCategory, RuleGroup};
+    use biome_configuration::generated::linter_options_check::config_side_rule_options_types;
+    use biome_css_syntax::CssLanguage;
+    use biome_graphql_syntax::GraphqlLanguage;
+    use biome_html_syntax::HtmlLanguage;
+    use biome_js_syntax::JsLanguage;
+    use biome_json_syntax::JsonLanguage;
+    use std::any::TypeId;
+    use std::collections::HashMap;
+
+    /// Collects `TypeId::of::<R::Options>()` for every rule via the registry visitor.
+    /// This is the "rule side" type — what the rule declares as `type Options`.
+    struct RuleSideOptionsVisitor {
+        types: HashMap<(&'static str, &'static str), TypeId>,
+    }
+
+    impl RuleSideOptionsVisitor {
+        fn collect_rule<R, L>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = L, Output: Clone>> + 'static,
+        {
+            let category = <R::Group as RuleGroup>::Category::CATEGORY;
+            if !matches!(category, RuleCategory::Lint) {
+                return;
+            }
+            self.types.insert(
+                (<R::Group as RuleGroup>::NAME, R::METADATA.name),
+                TypeId::of::<R::Options>(),
+            );
+        }
+    }
+
+    impl RegistryVisitor<JsLanguage> for RuleSideOptionsVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = JsLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.collect_rule::<R, JsLanguage>();
+        }
+    }
+
+    impl RegistryVisitor<JsonLanguage> for RuleSideOptionsVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = JsonLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.collect_rule::<R, JsonLanguage>();
+        }
+    }
+
+    impl RegistryVisitor<CssLanguage> for RuleSideOptionsVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = CssLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.collect_rule::<R, CssLanguage>();
+        }
+    }
+
+    impl RegistryVisitor<GraphqlLanguage> for RuleSideOptionsVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = GraphqlLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.collect_rule::<R, GraphqlLanguage>();
+        }
+    }
+
+    impl RegistryVisitor<HtmlLanguage> for RuleSideOptionsVisitor {
+        fn record_rule<R>(&mut self)
+        where
+            R: Rule<Options: Default, Query: Queryable<Language = HtmlLanguage, Output: Clone>>
+                + 'static,
+        {
+            self.collect_rule::<R, HtmlLanguage>();
+        }
+    }
+
+    /// Verifies that every lint rule's `type Options` matches the canonical options
+    /// type derived from the rule name (`biome_rule_options::{snake_name}::{Name}Options`).
+    ///
+    /// This catches copy-paste bugs where a rule accidentally uses another rule's
+    /// options type (e.g. `type Options = SomeOtherRuleOptions`). The configuration
+    /// layer always constructs `RuleOptions` using the canonical type, so a mismatch
+    /// causes a `TypeId` divergence that triggers a panic at runtime.
+    #[test]
+    fn rule_options_match_config_types() {
+        let config_side = config_side_rule_options_types();
+
+        let mut visitor = RuleSideOptionsVisitor {
+            types: HashMap::new(),
+        };
+        biome_js_analyze::visit_registry(&mut visitor);
+        biome_json_analyze::visit_registry(&mut visitor);
+        biome_css_analyze::visit_registry(&mut visitor);
+        biome_graphql_analyze::visit_registry(&mut visitor);
+        biome_html_analyze::visit_registry(&mut visitor);
+
+        let mut mismatches = Vec::new();
+        for (group, rule, config_type_id) in &config_side {
+            if let Some(rule_type_id) = visitor.types.get(&(*group, *rule))
+                && config_type_id != rule_type_id
+            {
+                mismatches.push(format!(
+                    "  {group}/{rule}: rule declares a different Options type than \
+                         biome_rule_options::{module}::{name}Options",
+                    module = biome_string_case::Case::Snake.convert(rule),
+                    name = {
+                        let mut c = rule.chars();
+                        match c.next() {
+                            None => String::new(),
+                            Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+                        }
+                    },
+                ));
+            }
+        }
+
+        if !mismatches.is_empty() {
+            panic!(
+                "Rule options type mismatches detected:\n{}\n\n\
+                 Each rule's `type Options` must match the canonical options type \
+                 generated from its name. Check for copy-paste errors.",
+                mismatches.join("\n")
+            );
+        }
+    }
+}
diff --git a/xtask/codegen/src/generate_configuration.rs b/xtask/codegen/src/generate_configuration.rs
index 114f491a004e..46aa324b120f 100644
--- a/xtask/codegen/src/generate_configuration.rs
+++ b/xtask/codegen/src/generate_configuration.rs
@@ -11,8 +11,8 @@ use proc_macro2::{Ident, Literal, Span};
 use quote::{format_ident, quote};
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::Path;
-use xtask_codegen::update;
 use xtask_codegen::{generate_analyzer_rule_options, get_analyzer_rule_options_path};
+use xtask_codegen::{to_capitalized, update};
 use xtask_glue::*;
 
 // ======= LINT ======
@@ -847,6 +847,50 @@ fn generate_for_groups(
     update(path, &xtask_glue::reformat(configuration)?, mode)?;
     update(file_name, &xtask_glue::reformat(push_rules)?, mode)?;
 
+    // Generate the options type-check test file for lint rules
+    if kind == RuleCategory::Lint {
+        let mut push_statements = String::new();
+        for rg in &rule_group_names {
+            let snake_name = Case::Snake.convert(rg.rule_name);
+            let options_type_name = format!("{}Options", to_capitalized(rg.rule_name));
+            push_statements.push_str(&format!(
+                "result.push((\"{group}\", \"{rule}\", TypeId::of::<biome_rule_options::{module}::{options}>()));\n",
+                group = rg.group_name,
+                rule = rg.rule_name,
+                module = snake_name,
+                options = options_type_name,
+            ));
+        }
+
+        let options_check = format!(
+            "\
+#![expect(clippy::vec_init_then_push)]
+use std::any::TypeId;
+
+/// Returns a list of `(group, rule, config_side_type_id)` for every lint rule.
+///
+/// The `TypeId` is derived from the rule name convention:
+/// `biome_rule_options::{{snake_case_name}}::{{PascalCaseName}}Options`
+///
+/// This is the type that the configuration layer uses when constructing
+/// [`RuleOptions`](biome_analyze::options::RuleOptions). If the rule's
+/// `type Options` doesn't match, the `debug_assert_eq!` inside
+/// `RuleOptions::value()` will fire at runtime.
+pub fn config_side_rule_options_types() -> Vec<(&'static str, &'static str, TypeId)> {{
+    let mut result = Vec::new();
+{push_statements}    result
+}}
+"
+        );
+
+        let options_check_file = push_directory.join("linter_options_check.rs");
+        update(
+            &options_check_file,
+            &xtask_glue::reformat(options_check)?,
+            mode,
+        )?;
+    }
+
     Ok(())
 }