kurnakovv · November 15, 2025 05:56 · kurnakovv · Jul 27, 2025
diff --git a/.editorconfig b/.editorconfig
 [*.cs]

 ##
 ## JetBrains ReSharper InspectCode
 ##
 # All rules here https://www.jetbrains.com/help/resharper/Reference__Code_Inspections_CSHARP.html

 # Method invocation is skipped
 resharper_invocation_is_skipped_highlighting = none

 # Part of the code cannot be parsed
 resharper_non_parsable_element_highlighting = none

 # Access to a static member of a type via a derived type
 resharper_access_to_static_member_via_derived_type_highlighting = none

 # Actual number of bytes read by 'Stream.Read()' is ignored
 resharper_stream_read_return_value_ignored_highlighting = none

 # Add explicit 'return' or 'continue' before local functions
 resharper_separate_local_functions_with_jump_statement_highlighting = none

 # Annotation duplicate in hierarchy
 resharper_annotation_redundancy_in_hierarchy_highlighting = none

 # Auto-property can be made get-only (non-private accessibility)
 resharper_auto_property_can_be_made_get_only_global_highlighting = none

 # Auto-property can be made get-only (private accessibility)
 resharper_auto_property_can_be_made_get_only_local_highlighting = none

 # Base member has 'params' parameter, but the overrider does not have it
 resharper_base_member_has_params_highlighting = none

 # Can simplify 'Contains' before 'Add'
 resharper_can_simplify_set_adding_with_single_call_highlighting = none

 # Cast expression can be replaced with explicit type arguments
 resharper_can_replace_cast_with_type_argument_highlighting = none

 # Cast expression can be replaced with explicit variable type
 resharper_can_replace_cast_with_variable_type_highlighting = none

 # Cast expression can be replaced with lambda return type
 resharper_can_replace_cast_with_lambda_return_type_highlighting = none

 # Cast expression can be replaced with simplified type arguments
 resharper_can_replace_cast_with_shorter_type_argument_highlighting = none

 # Change lock field type to 'System.Threading.Lock'
 resharper_change_field_type_to_system_threading_lock_highlighting = none

 # Check for reference equality instead
 resharper_check_for_reference_equality_instead_1_highlighting = none

 # Check for reference equality instead
 resharper_check_for_reference_equality_instead_3_highlighting = none

 # Check for reference equality instead
 resharper_check_for_reference_equality_instead_2_highlighting = none

 # Check for reference equality instead
 resharper_check_for_reference_equality_instead_4_highlighting = none

 # Class can be made sealed (non-inheritable) (non-private accessibility)
 resharper_class_can_be_sealed_global_highlighting = none

 # Class can be made sealed (non-inheritable) (private accessibility)
 resharper_class_can_be_sealed_local_highlighting = none

 # Confusing body-like statement
 resharper_misleading_body_like_statement_highlighting = none

 # Container nullability attribute usage with declaration of non-container type
 resharper_container_annotation_redundancy_highlighting = none

 # Convert 'if do while' into 'while'
 resharper_convert_if_do_to_while_highlighting = none

 # Convert 'if' into '||'
 resharper_convert_if_to_or_expression_highlighting = none

 # Convert local variable or field into constant (non-private accessibility)
 resharper_convert_to_constant_global_highlighting = none

 # Convert local variable or field into constant (private accessibility)
 resharper_convert_to_constant_local_highlighting = none

 # Declaration nullability inferred (parameter is inferred to be not null)
 resharper_annotate_not_null_parameter_highlighting = none

 # Declaration nullability inferred (parameter is inferred to be nullable)
 resharper_annotate_can_be_null_parameter_highlighting = none

 # Declaration nullability inferred (type member is inferred to be not null)
 resharper_annotate_not_null_type_member_highlighting = none

 # Declaration nullability inferred (type member is inferred to be nullable)
 resharper_annotate_can_be_null_type_member_highlighting = none

 # Dictionary item removal can be simplified with single 'Remove'
 resharper_can_simplify_dictionary_removing_with_single_call_highlighting = none

 # Dictionary lookup can be simplified with 'GetValueOrDefault'
 resharper_can_simplify_dictionary_try_get_value_with_get_value_or_default_highlighting = none

 # Dictionary lookup can be simplified with 'TryAdd'
 resharper_can_simplify_dictionary_lookup_with_try_add_highlighting = none

 # Dictionary lookup can be simplified with 'TryGetValue'
 resharper_can_simplify_dictionary_lookup_with_try_get_value_highlighting = none

 # Empty statement is redundant
 resharper_empty_statement_highlighting = none

 # Extract common property pattern
 resharper_extract_common_property_pattern_highlighting = none

 # Field can be made readonly (non-private accessibility)
 resharper_field_can_be_made_read_only_global_highlighting = none

 # Field can be made readonly (private accessibility)
 resharper_field_can_be_made_read_only_local_highlighting = none

 # Get-only auto-property is never assigned
 resharper_unassigned_get_only_auto_property_highlighting = none

 # Invert condition
 resharper_invert_condition_1_highlighting = none

 # Iteration variable can be declared with a more specific type
 resharper_more_specific_foreach_variable_type_available_highlighting = none

 # Join local variable declaration and assignment
 resharper_join_declaration_and_initializer_highlighting = none

 # Local function can be made static
 resharper_local_function_can_be_made_static_highlighting = none

 # Local variable has too wide declaration scope
 resharper_too_wide_local_variable_scope_highlighting = none

 # Make constructor in abstract class protected
 resharper_public_constructor_in_abstract_class_highlighting = none

 # Member can be made private (non-private accessibility)
 resharper_member_can_be_private_global_highlighting = none

 # Member can be made private (private accessibility)
 resharper_member_can_be_private_local_highlighting = none

 # Member can be made protected (non-private accessibility)
 resharper_member_can_be_protected_global_highlighting = none

 # Member can be made protected (private accessibility)
 resharper_member_can_be_protected_local_highlighting = none

 # Member can be made static (shared) (non-private accessibility)
 resharper_member_can_be_made_static_global_highlighting = none

 # Member can be made static (shared) (private accessibility)
 resharper_member_can_be_made_static_local_highlighting = none

 # Member or type can be made internal (friend)
 resharper_member_can_be_internal_highlighting = none

 # Method has async overload
 resharper_method_has_async_overload_highlighting = none

 # Method has async overload with cancellation support
 resharper_method_has_async_overload_with_cancellation_highlighting = none

 # Method supports cancellation
 resharper_method_supports_cancellation_highlighting = none

 # Missing XML comment for private or internal type or member
 resharper_internal_or_private_member_not_documented_highlighting = none

 # Multiple nullable attributes usage
 resharper_multiple_nullable_attributes_usage_highlighting = none

 # Nested string interpolation can be inlined
 resharper_nested_string_interpolation_highlighting = none

 # Nullability attribute usage with declaration of void or value type
 resharper_annotation_redundancy_at_value_type_highlighting = none

 # Nullability attribute used with declaration that cannot be directly referenced from other code
 resharper_not_observable_annotation_redundancy_highlighting = none

 # Parameter can be declared with the base type
 resharper_suggest_base_type_for_parameter_highlighting = none

 # Parameter of the constructor can be declared with the base type
 resharper_suggest_base_type_for_parameter_in_constructor_highlighting = none

 # Parameter type can be IEnumerable<T> (non-private accessibility)
 resharper_parameter_type_can_be_enumerable_global_highlighting = none

 # Parameter type can be IEnumerable<T> (private accessibility)
 resharper_parameter_type_can_be_enumerable_local_highlighting = none

 # Prefer using concrete value over 'default' or 'new()'
 resharper_prefer_concrete_value_over_default_highlighting = none

 # Property can be made init-only (non-private accessibility)
 resharper_property_can_be_made_init_only_global_highlighting = none

 # Property can be made init-only (private accessibility)
 resharper_property_can_be_made_init_only_local_highlighting = none

 # Put local function after 'return' or 'continue'
 resharper_move_local_function_after_jump_statement_highlighting = none

 # Redundant 'is'
 resharper_redundant_is_before_relational_pattern_highlighting = none

 # Remove constructor invocation
 resharper_remove_constructor_invocation_highlighting = none

 # Remove redundant statement
 resharper_remove_redundant_or_statement_false_highlighting = none

 # Remove redundant statement
 resharper_remove_redundant_or_statement_true_highlighting = none

 # Remove ToList()
 resharper_remove_to_list_1_highlighting = none

 # Remove ToList()
 resharper_remove_to_list_2_highlighting = none

 # Replace 'async' code with 'Task'-return
 resharper_replace_async_with_task_return_highlighting = none

 # Replace with FirstOrDefault($args$)
 resharper_replace_with_first_or_default_1_highlighting = none

 # Replace with FirstOrDefault($args$)
 resharper_replace_with_first_or_default_2_highlighting = none

 # Replace with FirstOrDefault($args$)
 resharper_replace_with_first_or_default_3_highlighting = none

 # Replace with FirstOrDefault($args$)
 resharper_replace_with_first_or_default_4_highlighting = none

 # Replace with LastOrDefault($args$)
 resharper_replace_with_last_or_default_1_highlighting = none

 # Replace with LastOrDefault($args$)
 resharper_replace_with_last_or_default_2_highlighting = none

 # Replace with LastOrDefault($args$)
 resharper_replace_with_last_or_default_3_highlighting = none

 # Replace with LastOrDefault($args$)
 resharper_replace_with_last_or_default_4_highlighting = none

 # Replace with OfType<T>()
 resharper_replace_with_of_type_1_highlighting = none

 # Replace with OfType<T>()
 resharper_replace_with_of_type_2_highlighting = none

 # Replace with OfType<T>()
 resharper_replace_with_of_type_3_highlighting = none

 # Replace with OfType<T>().Any()
 resharper_replace_with_of_type_any_1_highlighting = none

 # Replace with OfType<T>().Any() (replace with OfType<T>().Any(..))
 resharper_replace_with_of_type_any_2_highlighting = none

 # Replace with OfType<T>().Count()
 resharper_replace_with_of_type_count_1_highlighting = none

 # Replace with OfType<T>().Count() (replace with OfType<T>().Count(..))
 resharper_replace_with_of_type_count_2_highlighting = none

 # Replace with OfType<T>().First()
 resharper_replace_with_of_type_first_1_highlighting = none

 # Replace with OfType<T>().First() (replace with OfType<T>().First(..))
 resharper_replace_with_of_type_first_2_highlighting = none

 # Replace with OfType<T>().FirstOrDefault()
 resharper_replace_with_of_type_first_or_default_1_highlighting = none

 # Replace with OfType<T>().FirstOrDefault() (replace with OfType<T>().FirstOrDefault(..))
 resharper_replace_with_of_type_first_or_default_2_highlighting = none

 # Replace with OfType<T>().Last()
 resharper_replace_with_of_type_last_1_highlighting = none

 # Replace with OfType<T>().Last() (replace with OfType<T>().Last(..))
 resharper_replace_with_of_type_last_2_highlighting = none

 # Replace with OfType<T>().LastOrDefault()
 resharper_replace_with_of_type_last_or_default_1_highlighting = none

 # Replace with OfType<T>().LastOrDefault() (replace with OfType<T>().LastOrDefault(..))
 resharper_replace_with_of_type_last_or_default_2_highlighting = none

 # Replace with OfType<T>().LongCount()
 resharper_replace_with_of_type_long_count_highlighting = none

 # Replace with OfType<T>().Single()
 resharper_replace_with_of_type_single_1_highlighting = none

 # Replace with OfType<T>().Single() (replace with OfType<T>().Single(..))
 resharper_replace_with_of_type_single_2_highlighting = none

 # Replace with OfType<T>().SingleOrDefault()
 resharper_replace_with_of_type_single_or_default_1_highlighting = none

 # Replace with OfType<T>().SingleOrDefault() (replace with OfType<T>().SingleOrDefault(..))
 resharper_replace_with_of_type_single_or_default_2_highlighting = none

 # Replace with OfType<T>().Where() (replace with OfType<T>().Where(..))
 resharper_replace_with_of_type_where_highlighting = none

 # Replace with simple assignment
 resharper_replace_with_simple_assignment_true_highlighting = none

 # Replace with simple assignment
 resharper_replace_with_simple_assignment_false_highlighting = none

 # Replace with single assignment
 resharper_replace_with_single_assignment_false_highlighting = none

 # Replace with single assignment
 resharper_replace_with_single_assignment_true_highlighting = none

 # Replace with single call to Any(..)
 resharper_replace_with_single_call_to_any_highlighting = none

 # Replace with single call to Count(..)
 resharper_replace_with_single_call_to_count_highlighting = none

 # Replace with single call to First(..)
 resharper_replace_with_single_call_to_first_highlighting = none

 # Replace with single call to FirstOrDefault(..)
 resharper_replace_with_single_call_to_first_or_default_highlighting = none

 # Replace with single call to Last(..)
 resharper_replace_with_single_call_to_last_highlighting = none

 # Replace with single call to LastOrDefault(..)
 resharper_replace_with_single_call_to_last_or_default_highlighting = none

 # Replace with single call to Single(..)
 resharper_replace_with_single_call_to_single_highlighting = none

 # Replace with single call to SingleOrDefault(..)
 resharper_replace_with_single_call_to_single_or_default_highlighting = none

 # Replace with SingleOrDefault($args$)
 resharper_replace_with_single_or_default_1_highlighting = none

 # Replace with SingleOrDefault($args$)
 resharper_replace_with_single_or_default_2_highlighting = none

 # Replace with SingleOrDefault($args$)
 resharper_replace_with_single_or_default_3_highlighting = none

 # Replace with SingleOrDefault($args$)
 resharper_replace_with_single_or_default_4_highlighting = none

 # Return type can be IEnumerable<T> (non-private accessibility)
 resharper_return_type_can_be_enumerable_global_highlighting = none

 # Return type can be IEnumerable<T> (private accessibility)
 resharper_return_type_can_be_enumerable_local_highlighting = none

 # Simplify conditional ternary expression
 resharper_simplify_conditional_ternary_expression_highlighting = none

 # Simplify 'IsInstanceOfType()' invocation
 resharper_can_simplify_is_assignable_from_highlighting = none

 # Simplify LINQ expression (use 'All')
 resharper_simplify_linq_expression_use_all_highlighting = none

 # Simplify LINQ expression (use 'Any')
 resharper_simplify_linq_expression_use_any_highlighting = none

 # Simplify negated pattern
 resharper_double_negation_in_pattern_highlighting = none

 # Simplify negated relational pattern
 resharper_negation_of_relational_pattern_highlighting = none

 # Simplify negative equality expression
 resharper_negative_equality_expression_highlighting = none

 # Specify string comparison explicitly
 resharper_specify_string_comparison_highlighting = none

 # Specify string culture explicitly
 resharper_specify_a_culture_in_string_conversion_explicitly_highlighting = none

 # String literal can be inlined
 resharper_string_literal_as_interpolation_argument_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, int, string, int) is culture-specific)
 resharper_string_compare_is_culture_specific_4_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, int, string, int, bool) is culture-specific)
 resharper_string_compare_is_culture_specific_5_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, int, string, int, bool) is culture-specific)
 resharper_string_compare_is_culture_specific_6_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, string) is culture-specific)
 resharper_string_compare_is_culture_specific_1_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, string, bool) is culture-specific)
 resharper_string_compare_is_culture_specific_2_highlighting = none

 # String.Compare is culture-specific (string.Compare(string, string, bool) is culture-specific)
 resharper_string_compare_is_culture_specific_3_highlighting = none

 # String.CompareTo is culture-specific
 resharper_string_compare_to_is_culture_specific_highlighting = none

 # String.EndsWith is culture-specific (string.EndsWith(string) is culture-specific)
 resharper_string_ends_with_is_culture_specific_highlighting = none

 # String.IndexOf is culture-specific (string.IndexOf(string) is culture-specific)
 resharper_string_index_of_is_culture_specific_1_highlighting = none

 # String.IndexOf is culture-specific (string.IndexOf(string, int) is culture-specific)
 resharper_string_index_of_is_culture_specific_2_highlighting = none

 # String.IndexOf is culture-specific (string.IndexOf(string, int) is culture-specific)
 resharper_string_index_of_is_culture_specific_3_highlighting = none

 # String.LastIndexOf is culture-specific (string.LastIndexOf(string) is culture-specific)
 resharper_string_last_index_of_is_culture_specific_1_highlighting = none

 # String.LastIndexOf is culture-specific (string.LastIndexOf(string, int) is culture-specific)
 resharper_string_last_index_of_is_culture_specific_2_highlighting = none

 # String.LastIndexOf is culture-specific (string.LastIndexOf(string, int) is culture-specific)
 resharper_string_last_index_of_is_culture_specific_3_highlighting = none

 # String.StartsWith is culture-specific (string.StartsWith(string) is culture-specific)
 resharper_string_starts_with_is_culture_specific_highlighting = none

 # Struct can be made readonly
 resharper_struct_can_be_made_read_only_highlighting = none

 # Struct lacks 'IEquatable' implementation (non-private accessibility)
 resharper_struct_lacks_i_equatable_global_highlighting = none

 # Struct lacks 'IEquatable' implementation (private accessibility)
 resharper_struct_lacks_i_equatable_local_highlighting = none

 # Struct member can be made readonly
 resharper_struct_member_can_be_made_read_only_highlighting = none

 # Struct with default equality members is used for comparison (non-private accessibility)
 resharper_default_struct_equality_is_used_global_highlighting = none

 # Struct with default equality members is used for comparison (private accessibility)
 resharper_default_struct_equality_is_used_local_highlighting = none

 # try-catch and try-finally statements can be merged
 resharper_try_statements_can_be_merged_highlighting = none

 # Type can be made file-local
 resharper_member_can_be_file_local_highlighting = none

 # Type parameter could be declared as covariant or contravariant
 resharper_type_parameter_can_be_variant_highlighting = none

 # Type with suspicious equality is used in a record (non-private accessibility)
 resharper_type_with_suspicious_equality_is_used_in_record_global_highlighting = none

 # Type with suspicious equality is used in a record (private accessibility)
 resharper_type_with_suspicious_equality_is_used_in_record_local_highlighting = none

 # Usage of default struct equality
 resharper_usage_of_default_struct_equality_highlighting = none

 # Use 'ArgumentNullException.ThrowIfNull'
 resharper_use_throw_if_null_method_highlighting = none

 # Use array creation expression
 resharper_use_array_creation_expression_1_highlighting = none

 # Use array creation expression
 resharper_use_array_creation_expression_2_highlighting = none

 # Use 'Array.Empty<T>()'
 resharper_use_array_empty_method_highlighting = none

 # Use cancellation token
 resharper_use_cancellation_token_for_i_async_enumerable_highlighting = none

 # Use compiler-supported nullable attributes
 resharper_use_nullable_attributes_supported_by_compiler_highlighting = none

 # Use 'EventArgs.Empty'
 resharper_use_event_args_empty_field_highlighting = none

 # Use indexed property
 resharper_use_indexed_property_highlighting = none

 # Use 'is' operator
 resharper_can_simplify_is_instance_of_type_highlighting = none

 # Use method Any()
 resharper_use_method_any_0_highlighting = none

 # Use method Any()
 resharper_use_method_any_1_highlighting = none

 # Use method Any()
 resharper_use_method_any_2_highlighting = none

 # Use method Any()
 resharper_use_method_any_3_highlighting = none

 # Use method Any()
 resharper_use_method_any_4_highlighting = none

 # Use 'String.IsNullOrEmpty'
 resharper_replace_with_string_is_null_or_empty_highlighting = none

 # Use 'Type.EmptyTypes'
 resharper_use_empty_types_field_highlighting = none

 # '#warning' directive
 resharper_c_sharp_warnings_cs1030_highlighting = none

 # [InterpolatedStringHandlerArgument] has no effect when applied to lambda parameters and will be ignored at the call site.
 resharper_c_sharp_warnings_cs8971_highlighting = none

 # A default value is specified for 'ref readonly' parameter, but 'ref readonly' should be used only for references. Consider declaring the parameter as 'in'.
 resharper_c_sharp_warnings_cs9200_highlighting = none

 # A local variable is returned by reference but was initialized to a value that cannot be returned by reference.
 resharper_c_sharp_warnings_cs9082_highlighting = none

 # A member of a variable is returned by reference but was initialized to a value that cannot be returned by reference
 resharper_c_sharp_warnings_cs9083_highlighting = none

 # A method marked [DoesNotReturn] should not return.
 resharper_c_sharp_warnings_cs8763_highlighting = none

 # A possible null value may not be used for a type marked with [NotNull] or [DisallowNull].
 resharper_c_sharp_warnings_cs8607_highlighting = none

 # A previous catch clause already catches all exceptions
 resharper_c_sharp_warnings_cs1058_highlighting = none

 # A result of a stackalloc expression in this context may be exposed outside of the containing method.
 resharper_c_sharp_warnings_cs9081_highlighting = none

 # A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement
 resharper_c_sharp_warnings_cs9216_highlighting = none

 # Access to a member through 'base' keyword from anonymous method, lambda expression, query expression or iterator results in unverifiable code
 resharper_c_sharp_warnings_cs1911_highlighting = none

 # Alignment value 'value' has a magnitude greater than 'magnitude limit' and may result in a large formatted string.
 resharper_c_sharp_warnings_cs8094_highlighting = none

 # Ambiguous reference in XML comment
 resharper_c_sharp_warnings_cs1574_highlighting = none

 # Argument cannot be used as an output for parameter due to differences in the nullability of reference types.
 resharper_c_sharp_warnings_cs8624_highlighting = none

 # Argument cannot be used for corresponding parameter due to differences in the nullability of reference types.
 resharper_c_sharp_warnings_cs8620_highlighting = none

 # Argument should be a variable because it is passed to a 'ref readonly' parameter.
 resharper_c_sharp_warnings_cs9193_highlighting = none

 # Argument should be passed with the 'in' keyword.
 resharper_c_sharp_warnings_cs9195_highlighting = none

 # Assignment in conditional expression
 resharper_c_sharp_warnings_cs0665_highlighting = none

 # Assignment made to same variable
 resharper_c_sharp_warnings_cs1717_highlighting = none

 # Async function without await expression
 resharper_c_sharp_warnings_cs1998_highlighting = none

 # Async method invocation without await expression
 resharper_c_sharp_warnings_cs4014_highlighting = none

 # Asynchronous 'Main' method will not be used as an entry point because a synchronous entry point was found.
 resharper_c_sharp_warnings_cs8892_highlighting = none

 # Async-iterator has one or more parameters of type 'CancellationToken' but none of them is annotated with the 'EnumeratorCancellation' attribute.
 resharper_c_sharp_warnings_cs8425_highlighting = none

 # 'attribute modifier' is not a recognized attribute location. All attributes in this block will be ignored
 resharper_c_sharp_warnings_cs0658_highlighting = none

 # 'attribute modifier' is not a valid attribute location for this declaration. All attributes in this block will be ignored
 resharper_c_sharp_warnings_cs0657_highlighting = none

 # Badly formed XML in included comments file
 resharper_c_sharp_warnings_cs1592_highlighting = none

 # Bitwise-or operator used on a sign-extended operand.
 resharper_c_sharp_warnings_cs0675_highlighting = none

 # Call to a non-readonly member from a 'readonly' member results in an implicit copy of 'this'
 resharper_c_sharp_warnings_cs8656_highlighting = none

 # Cannot convert null literal to non-nullable reference type.
 resharper_c_sharp_warnings_cs8625_highlighting = none

 # Cannot resolve reference in XML comment
 resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting = none

 # Class overrides Object.Equals(object o) but not Object.GetHashCode()
 resharper_c_sharp_warnings_cs0659_highlighting = none

 # Code is unreachable
 resharper_c_sharp_warnings_cs0162_highlighting = none

 # Collection expression may incur unexpected heap allocations
 resharper_c_sharp_warnings_cs9208_highlighting = none

 # Collection expression may incur unexpected heap allocations due to the use of '..' spreads
 resharper_c_sharp_warnings_cs9209_highlighting = none

 # Comparing with null of nullable value type always produces 'false'
 resharper_c_sharp_warnings_cs0464_highlighting = none

 # Comparison to integral constant is useless; the constant is outside the range of type 'type'.
 resharper_c_sharp_warnings_cs0652_highlighting = none

 # Converting method group to non-delegate type 'object'.
 resharper_c_sharp_warnings_cs8974_highlighting = none

 # Converting null literal or possible null value to non-nullable type.
 resharper_c_sharp_warnings_cs8600_highlighting = none

 # Declaring new protected member in sealed class is the same as declaring it as private
 resharper_c_sharp_warnings_cs0628_highlighting = none

 # Default value specified for parameter will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
 resharper_c_sharp_warnings_cs1066_highlighting = none

 # Dereference of a possibly null reference.
 resharper_c_sharp_warnings_cs8602_highlighting = none

 # Duplicate param tag in XML comment
 resharper_c_sharp_warnings_cs1571_highlighting = none

 # Duplicate typeparam tag in XML comment
 resharper_c_sharp_warnings_cs1710_highlighting = none

 # Empty switch block
 resharper_c_sharp_warnings_cs1522_highlighting = none

 # Field is never used
 resharper_unused_field_compiler_highlighting = none

 # Filter expression is a constant, consider removing the filter
 resharper_c_sharp_warnings_cs7095_highlighting = none

 # Given expression always matches the provided pattern
 resharper_c_sharp_warnings_cs8794_highlighting = none

 # Given expression is always of the provided type
 resharper_c_sharp_warnings_cs0183_highlighting = none

 # Given expression is never of the provided type
 resharper_c_sharp_warnings_cs0184_highlighting = none

 # 'goto case' value is not implicitly convertible to required type
 resharper_c_sharp_warnings_cs0469_highlighting = none

 # In language version preview, the 'field' keyword binds to a synthesized backing field for the property
 resharper_c_sharp_warnings_cs9258_highlighting = none

 # Incorrect signature in XML comment
 resharper_c_sharp_warnings_cs1580_highlighting = none

 # Inline array conversion operator will not be used for conversion from expression of the declaring type.
 resharper_c_sharp_warnings_cs9183_highlighting = none

 # Inline array indexer will not be used for element access expression.
 resharper_c_sharp_warnings_cs9181_highlighting = none

 # Inline array 'Slice' method will not be used for element access expression.
 resharper_c_sharp_warnings_cs9182_highlighting = none

 # 'Inline arrays' language feature is not supported for inline array types with element field which is either a 'ref' field, or has type that is not valid as a type argument.
 resharper_c_sharp_warnings_cs9184_highlighting = none

 # Introducing a 'Finalize' method can interfere with destructor invocation
 resharper_c_sharp_warnings_cs0465_highlighting = none

 # Invalid XML in XML comment
 resharper_c_sharp_warnings_cs1570_highlighting = none

 # Invalid XML include element
 resharper_c_sharp_warnings_cs1590_highlighting = none

 # Keyword 'new' is redundant
 resharper_c_sharp_warnings_cs0109_highlighting = none

 # Keyword 'new' is required
 resharper_c_sharp_warnings_cs0108_cs0114_highlighting = none

 # Member cannot be used in this attribute.
 resharper_c_sharp_warnings_cs8776_highlighting = none

 # Member must conditionally have a non-null value when exiting a function.
 resharper_c_sharp_warnings_cs8775_highlighting = none

 # Member must have a non-null value when exiting.
 resharper_c_sharp_warnings_cs8774_highlighting = none

 # Member overrides obsolete member
 resharper_c_sharp_warnings_cs0672_highlighting = none

 # Method lacks '[DoesNotReturn]' annotation in order to match implemented or overridden member.
 resharper_c_sharp_warnings_cs8770_highlighting = none

 # Missing XML comment for publicly visible type or member
 resharper_c_sharp_warnings_cs1591_highlighting = none

 # Multiple override candidates at run-time
 resharper_c_sharp_warnings_cs1957_highlighting = none

 # Multiple Shaders with the same name found
 resharper_shader_lab_shader_reference_multiple_candidates_highlighting = none

 # Namespace should be default namespace of this project
 resharper_c_sharp_warnings_wme006_highlighting = none

 # Non-accessed field
 resharper_not_accessed_field_compiler_highlighting = none

 # Non-accessed local variable
 resharper_not_accessed_variable_compiler_highlighting = none

 # Non-nullable backing field is uninitialized.
 resharper_c_sharp_warnings_cs9264_highlighting = none

 # Non-nullable member is uninitialized.
 resharper_c_sharp_warnings_cs8618_highlighting = none

 # Nullability mismatch in constraints for type parameter.
 resharper_c_sharp_warnings_cs8633_highlighting = none

 # Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type.
 resharper_c_sharp_warnings_cs8643_highlighting = none

 # Nullability of reference types in interface implemented by the base type doesn't match.
 resharper_c_sharp_warnings_cs8644_highlighting = none

 # Nullability of reference types in return type doesn't match implemented member.
 resharper_c_sharp_warnings_cs8616_highlighting = none

 # Nullability of reference types in return type doesn't match implicitly implemented member.
 resharper_c_sharp_warnings_cs8613_highlighting = none

 # Nullability of reference types in return type doesn't match overridden member.
 resharper_c_sharp_warnings_cs8609_highlighting = none

 # Nullability of reference types in return type doesn't match partial method declaration.
 resharper_c_sharp_warnings_cs8819_highlighting = none

 # Nullability of reference types in return type doesn't match the target delegate (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8621_highlighting = none

 # Nullability of reference types in return type in interceptor method doesn't match interceptable method'
 resharper_c_sharp_warnings_cs9159_highlighting = none

 # Nullability of reference types in source type doesn't match target type.
 resharper_c_sharp_warnings_cs8619_highlighting = none

 # Nullability of reference types in type doesn't match implemented member.
 resharper_c_sharp_warnings_cs8615_highlighting = none

 # Nullability of reference types in type doesn't match implicitly implemented member.
 resharper_c_sharp_warnings_cs8612_highlighting = none

 # Nullability of reference types in type doesn't match overridden member.
 resharper_c_sharp_warnings_cs8608_highlighting = none

 # Nullability of reference types in type of a parameter doesn't match the target delegate (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8622_highlighting = none

 # Nullability of reference types in type of parameter doesn't match implemented member.
 resharper_c_sharp_warnings_cs8617_highlighting = none

 # Nullability of reference types in type of parameter doesn't match implicitly implemented member.
 resharper_c_sharp_warnings_cs8614_highlighting = none

 # Nullability of reference types in type of parameter doesn't match interceptable method
 resharper_c_sharp_warnings_cs9158_highlighting = none

 # Nullability of reference types in type of parameter doesn't match overridden member.
 resharper_c_sharp_warnings_cs8610_highlighting = none

 # Nullability of reference types in type of parameter doesn't match partial member declaration.
 resharper_c_sharp_warnings_cs8611_highlighting = none

 # Nullability of return type doesn't match implemented member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8768_highlighting = none

 # Nullability of return type doesn't match implicitly implemented member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8766_highlighting = none

 # Nullability of return type doesn't match overridden member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8764_highlighting = none

 # Nullability of type argument doesn't match 'class' constraint.
 resharper_c_sharp_warnings_cs8634_highlighting = none

 # Nullability of type argument doesn't match constraint type.
 resharper_c_sharp_warnings_cs8631_highlighting = none

 # Nullability of type argument doesn't match 'notnull' constraint.
 resharper_c_sharp_warnings_cs8714_highlighting = none

 # Nullability of type of parameter doesn't match implemented member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8769_highlighting = none

 # Nullability of type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8767_highlighting = none

 # Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes).
 resharper_c_sharp_warnings_cs8765_highlighting = none

 # Nullable value type may be null.
 resharper_c_sharp_warnings_cs8629_highlighting = none

 # Object or collection initializer implicitly dereferences possibly null member.
 resharper_c_sharp_warnings_cs8670_highlighting = none

 # Obsolete member overrides non-obsolete member
 resharper_c_sharp_warnings_cs0809_highlighting = none

 # Obsolete members should not be required.
 resharper_c_sharp_warnings_cs9042_highlighting = none

 # Operator '==' or operator '!=' with 'Object.Equals(object o)' and 'Object.GetHashCode()' not overridden
 resharper_c_sharp_warnings_cs0660_cs0661_highlighting = none

 # Opt in to preview features before using them.
 resharper_c_sharp_warnings_ca2252_highlighting = none

 # Parameter has no matching param tag in the XML comment
 resharper_c_sharp_warnings_cs1573_highlighting = none

 # Parameter has params modifier in lambda but not in target delegate type.
 resharper_c_sharp_warnings_cs9100_highlighting = none

 # Parameter is captured into the state of the enclosing type and its value is also passed to the base constructor. The value might be captured by the base class as well.
 resharper_c_sharp_warnings_cs9107_highlighting = none

 # Parameter is captured into the state of the enclosing type and its value is also used to initialize a field, property, or event.
 resharper_c_sharp_warnings_cs9124_highlighting = none

 # Parameter must conditionally have a non-null value when exiting a function.
 resharper_c_sharp_warnings_cs8762_highlighting = none

 # Parameter must have a non-null value when exiting because parameter mentioned in [NotNullIfNotNull] annotation is non-null.
 resharper_c_sharp_warnings_cs8824_highlighting = none

 # Parameter must have a non-null value when exiting.
 resharper_c_sharp_warnings_cs8777_highlighting = none

 # Parameter occurs after interpolated string handler parameter in the parameter list.
 resharper_c_sharp_warnings_cs8947_highlighting = none

 # Partial method declarations have inconsistent nullability for type parameter.
 resharper_c_sharp_warnings_cs8667_highlighting = none

 # Partial property declarations have signature differences.
 resharper_c_sharp_warnings_cs9256_highlighting = none

 # Possible mistaken empty statement
 resharper_c_sharp_warnings_cs0642_highlighting = none

 # Possible null reference argument for a parameter.
 resharper_c_sharp_warnings_cs8604_highlighting = none

 # Possible null reference assignment.
 resharper_c_sharp_warnings_cs8601_highlighting = none

 # Possible null reference return.
 resharper_c_sharp_warnings_cs8603_highlighting = none

 # Possible unintended reference comparison
 resharper_c_sharp_warnings_cs0252_cs0253_highlighting = none

 # Possibly incorrect assignment to local which is the argument to a 'using' or 'lock' statement
 resharper_c_sharp_warnings_cs0728_highlighting = none

 # Primary constructor parameter is shadowed by a member from base type.
 resharper_c_sharp_warnings_cs9179_highlighting = none

 # Record defined 'Equals' but not 'GetHashCode'
 resharper_c_sharp_warnings_cs8851_highlighting = none

 # Reference kind modifier of parameter doesn't match the corresponding parameter in hidden member.
 resharper_c_sharp_warnings_cs9197_highlighting = none

 # Reference kind modifier of parameter doesn't match the corresponding parameter in overridden or implemented member.
 resharper_c_sharp_warnings_cs9196_highlighting = none

 # Reference kind modifier of parameter doesn't match the corresponding parameter in target.
 resharper_c_sharp_warnings_cs9198_highlighting = none

 # Reference to a volatile field will not be treated as volatile
 resharper_c_sharp_warnings_cs0420_highlighting = none

 # Return value must be non-null because parameter mentioned in [NotNullIfNotNull] annotation is non-null.
 resharper_c_sharp_warnings_cs8825_highlighting = none

 # Signatures of interceptable and interceptor methods do not match
 resharper_c_sharp_warnings_cs9154_highlighting = none

 # Source file has exceeded the limit of 16,707,565 lines representable in the PDB; debug information will be incorrect
 resharper_c_sharp_warnings_cs1687_highlighting = none

 # Static type in 'is' or 'as' operator.
 resharper_c_sharp_warnings_cs7023_highlighting = none

 # Struct member returns 'this' or other instance members by reference.
 resharper_c_sharp_warnings_cs9084_highlighting = none

 # Syntax error in XML comment
 resharper_c_sharp_warnings_cs1584_highlighting = none

 # Taking address of marshal-by-reference class field
 resharper_c_sharp_warnings_cs0197_highlighting = none

 # The '&' operator should not be used on parameters or local variables in async methods.
 resharper_c_sharp_warnings_cs9123_highlighting = none

 # The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 resharper_c_sharp_warnings_cs8632_highlighting = none

 # The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. Auto-generated code requires an explicit '#nullable' directive in source.
 resharper_c_sharp_warnings_cs8669_highlighting = none

 # The branches of the ref conditional operator refer to variables with incompatible declaration scopes.
 resharper_c_sharp_warnings_cs9086_highlighting = none

 # The CallerArgumentExpressionAttribute applied to parameter will have no effect because it's self-referential
 resharper_c_sharp_warnings_cs8965_highlighting = none

 # The CallerArgumentExpressionAttribute is applied with an invalid parameter name.
 resharper_c_sharp_warnings_cs8963_highlighting = none

 # The CallerArgumentExpressionAttribute will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
 resharper_c_sharp_warnings_cs8966_highlighting = none

 # The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerFilePathAttribute
 resharper_c_sharp_warnings_cs8961_highlighting = none

 # The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerLineNumberAttribute
 resharper_c_sharp_warnings_cs8960_highlighting = none

 # The CallerArgumentExpressionAttribute will have no effect; it is overridden by the CallerMemberNameAttribute
 resharper_c_sharp_warnings_cs8962_highlighting = none

 # The default parameter value does not match in the target delegate type.
 resharper_c_sharp_warnings_cs9099_highlighting = none

 # The 'EnumeratorCancellation' attribute is only effective on a parameter of type 'CancellationToken' in an async-iterator method returning 'IAsyncEnumerable<>'.
 resharper_c_sharp_warnings_cs8424_highlighting = none

 # The given expression always matches the provided constant.
 resharper_c_sharp_warnings_cs8520_highlighting = none

 # The given expression never matches the provided pattern.
 resharper_c_sharp_warnings_cs8519_highlighting = none

 # The 'l' suffix is easily confused with the digit '1'
 resharper_c_sharp_warnings_cs0078_highlighting = none

 # The 'Main' method will not be used as an entry point because compilation unit with top-level statements was found.
 resharper_c_sharp_warnings_cs7022_highlighting = none

 # The 'ref' modifier for an argument corresponding to 'in' parameter is equivalent to 'in'. Consider using 'in' instead.
 resharper_c_sharp_warnings_cs9191_highlighting = none

 # The 'ref' modifier for an argument corresponding to 'in' parameter is equivalent to 'in'. Consider using 'in' instead.
 resharper_c_sharp_warnings_cs9192_highlighting = none

 # The result of the expression is always 'null' of nullable type
 resharper_c_sharp_warnings_cs0458_highlighting = none

 # The result of the expression is always 'true' or 'false' since a value of value type is never equal to 'null'
 resharper_c_sharp_warnings_cs0472_highlighting = none

 # The result of the expression is always 'true' or 'false' since a value of value type is never equal to 'null'
 resharper_c_sharp_warnings_cs8073_highlighting = none

 # The 'scoped' modifier of a parameter doesn't match target delegate.
 resharper_c_sharp_warnings_cs9073_highlighting = none

 # The 'scoped' modifier of parameter doesn't match overridden or implemented member.
 resharper_c_sharp_warnings_cs9074_highlighting = none

 # The switch expression does not handle all possible inputs (it is not exhaustive).
 resharper_c_sharp_warnings_cs8509_highlighting = none

 # The switch expression does not handle all possible values of its input type (it is not exhaustive). However, a pattern with a 'when' clause might successfully match this value.
 resharper_c_sharp_warnings_cs8846_highlighting = none

 # The switch expression does not handle some null inputs (it is not exhaustive).
 resharper_c_sharp_warnings_cs8655_highlighting = none

 # The switch expression does not handle some null inputs (it is not exhaustive). However, a pattern with a 'when' clause might successfully match this value.
 resharper_c_sharp_warnings_cs8847_highlighting = none

 # The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.
 resharper_c_sharp_warnings_cs8524_highlighting = none

 # The tuple element name is ignored because a different name or no name is specified by the target type.
 resharper_c_sharp_warnings_cs8123_highlighting = none

 # The tuple element name is ignored because a different name or no name is specified on the other side of the tuple == or != operator.
 resharper_c_sharp_warnings_cs8383_highlighting = none

 # The type name only contains lower-cased ASCII characters. Such names may become reserved for the language
 resharper_c_sharp_warnings_cs8981_highlighting = none

 # There is no defined ordering between fields in multiple declarations of partial struct. To specify an ordering, all instance fields must be in the same declaration.
 resharper_c_sharp_warnings_cs0282_highlighting = none

 # This ref-assigns a value that can only escape the current method through a return statement.
 resharper_c_sharp_warnings_cs9093_highlighting = none

 # This ref-assigns a value that has a wider value escape scope than the target allowing assignment through the target of values with narrower escapes scopes.
 resharper_c_sharp_warnings_cs9097_highlighting = none

 # This ref-assigns an expression to a variable with a narrower escape scope.
 resharper_c_sharp_warnings_cs9085_highlighting = none

 # This returns a member of local by reference but it is not a ref local.
 resharper_c_sharp_warnings_cs9092_highlighting = none

 # This returns a parameter by reference but it is not a ref parameter.
 resharper_c_sharp_warnings_cs9087_highlighting = none

 # This returns a parameter by reference but it is scoped to the current method.
 resharper_c_sharp_warnings_cs9088_highlighting = none

 # This returns a parameter by reference through a ref parameter; but it can only safely be returned in a return statement.
 resharper_c_sharp_warnings_cs9094_highlighting = none

 # This returns by reference a member of parameter that is not a ref or out parameter.
 resharper_c_sharp_warnings_cs9089_highlighting = none

 # This returns by reference a member of parameter that is scoped to the current method.
 resharper_c_sharp_warnings_cs9090_highlighting = none

 # This returns by reference a member of parameter through a ref parameter; but it can only safely be returned in a return statement.
 resharper_c_sharp_warnings_cs9095_highlighting = none

 # This returns local by reference but it is not a ref local.
 resharper_c_sharp_warnings_cs9091_highlighting = none

 # This takes the address of, gets the size of, or declares a pointer to a managed type.
 resharper_c_sharp_warnings_cs8500_highlighting = none

 # Thrown value may be null.
 resharper_c_sharp_warnings_cs8597_highlighting = none

 # Type is already listed in the interface list with different nullability of reference types.
 resharper_c_sharp_warnings_cs8645_highlighting = none

 # Type is for evaluation purposes only and is subject to change or removal in future updates.
 resharper_c_sharp_warnings_cs8305_highlighting = none

 # Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
 resharper_c_sharp_warnings_cs9204_highlighting = none

 # Type parameter has no matching typeparam tag in the XML comment
 resharper_c_sharp_warnings_cs1712_highlighting = none

 # Type parameter has the same name as a type parameter from the outer type
 resharper_c_sharp_warnings_cs0693_highlighting = none

 # Types and aliases should not be named 'record'
 resharper_c_sharp_warnings_cs8860_highlighting = none

 # Unable to include XML fragment
 resharper_c_sharp_warnings_cs1589_highlighting = none

 # Unassigned field
 resharper_unassigned_field_compiler_highlighting = none

 # Unassigned readonly field
 resharper_unassigned_readonly_field_compiler_highlighting = none

 # Unboxing a possibly null value.
 resharper_c_sharp_warnings_cs8605_highlighting = none

 # Unresolved Shader name
 resharper_shader_lab_shader_reference_not_resolved_highlighting = none

 # Unused local variable
 resharper_unused_variable_compiler_highlighting = none

 # Use of a variable in this context may expose referenced variables outside of their declaration scope.
 resharper_c_sharp_warnings_cs9080_highlighting = none

 # Use of obsolete symbol
 resharper_c_sharp_warnings_cs0618_highlighting = none

 # Use of obsolete symbol (without message)
 resharper_c_sharp_warnings_cs0612_highlighting = none

 # Using 'is' to test compatibility with 'dynamic' is essentially identical to testing compatibility with 'Object' and will succeed for all non-null values
 resharper_c_sharp_warnings_cs1981_highlighting = none

 # XML comment has a 'param' tag for 'Parameter', but there is no parameter by that name
 resharper_c_sharp_warnings_cs1572_highlighting = none

 # XML comment has a 'typeparam' tag for 'TypeParameter', but there is no type parameter by that name
 resharper_c_sharp_warnings_cs1711_highlighting = none

 # XML comment has cref attribute that refers to a type parameter
 resharper_c_sharp_warnings_cs1723_highlighting = none

 # XML comment is not placed on a valid language element
 resharper_c_sharp_warnings_cs1587_highlighting = none

 # Base type is required
 resharper_required_base_types_is_not_inherited_highlighting = none

 # BaseTypeRequired attribute supports only classes and interfaces
 resharper_unsupported_required_base_type_highlighting = none

 # Inconsistent Naming
 resharper_inconsistent_naming_highlighting = none

 # Namespace does not correspond to file location
 resharper_check_namespace_highlighting = none

 # Non-nullable or required member is not initialized at constructor exit
 resharper_not_null_or_required_member_is_not_initialized_highlighting = none

 # Possible 'null' assignment to non-nullable entity
 resharper_assign_null_to_not_null_attribute_highlighting = none

 # Possible violation of 'ValueRange'/'NonNegativeValue' attribute
 resharper_value_range_attribute_violation_highlighting = none

 # Problem in contract annotation definition
 resharper_contract_annotation_not_parsed_highlighting = none

 # Required base type conflicting another type
 resharper_required_base_types_conflict_highlighting = none

 # Type specified in '[BaseTypeRequired]' attribute conflicts another type
 resharper_required_base_types_direct_conflict_highlighting = none

 # Values of types marked with 'CannotApplyEqualityOperatorAttribute' should be compared using 'Equals()'
 resharper_cannot_apply_equality_operator_to_type_highlighting = none

 # Database function must not be called in non-database context
 resharper_entity_framework_client_side_db_function_call_highlighting = none

 # Function is not convertible to SQL and must not be called in the database context
 resharper_entity_framework_unsupported_server_side_function_call_highlighting = none

 # Possible multiple queries to the database (N+1 problem)
 resharper_entity_framework_n_plus_one_usage_highlighting = none

 # Possible multiple queries to the database for related entities (N+1 problem)
 resharper_entity_framework_n_plus_one_query_highlighting = none

 # Possible performance issues caused by unlimited string length
 resharper_entity_framework_model_validation_unlimited_string_length_highlighting = none

 # Query can return incomplete data for related entities
 resharper_entity_framework_n_plus_one_incomplete_data_query_highlighting = none

 # The relationship defined by this property contributes to a dependency loop
 resharper_entity_framework_model_validation_circular_dependency_highlighting = none

 # Usage of navigational property can return incomplete data
 resharper_entity_framework_n_plus_one_incomplete_data_usage_highlighting = none

 # Incorrect blank lines (blank lines are missing elsewhere)
 resharper_missing_blank_lines_highlighting = none

 # Incorrect blank lines (blank lines are redundant elsewhere)
 resharper_redundant_blank_lines_highlighting = none

 # Incorrect blank lines (incorrect number of blank lines near braces)
 resharper_incorrect_blank_lines_near_braces_highlighting = none

 # Incorrect indent (around child statement)
 resharper_bad_child_statement_indent_highlighting = none

 # Incorrect indent (around declaration braces)
 resharper_bad_declaration_braces_indent_highlighting = none

 # Incorrect indent (around expression braces)
 resharper_bad_expression_braces_indent_highlighting = none

 # Incorrect indent (around namespace braces)
 resharper_bad_namespace_braces_indent_highlighting = none

 # Incorrect indent (around preprocessor directive)
 resharper_bad_preprocessor_indent_highlighting = none

 # Incorrect indent (around statement braces)
 resharper_bad_control_braces_indent_highlighting = none

 # Incorrect indent (around switch statement)
 resharper_bad_switch_braces_indent_highlighting = none

 # Incorrect indent (incorrect indent size)
 resharper_wrong_indent_size_highlighting = none

 # Incorrect indent (indent level is not restored)
 resharper_outdent_is_off_prev_level_highlighting = none

 # Incorrect indent (missing indent/outdent elsewhere)
 resharper_missing_indent_highlighting = none

 # Incorrect indent (redundant indent/outdent elsewhere)
 resharper_bad_indent_highlighting = none

 # Incorrect indent (tabs/spaces mismatch)
 resharper_tabs_and_spaces_mismatch_highlighting = none

 # Incorrect line breaks (around comma in lists)
 resharper_bad_list_line_breaks_highlighting = none

 # Incorrect line breaks (around declaration braces)
 resharper_bad_declaration_braces_line_breaks_highlighting = none

 # Incorrect line breaks (around empty braces)
 resharper_bad_empty_braces_line_breaks_highlighting = none

 # Incorrect line breaks (around expression braces)
 resharper_bad_expression_braces_line_breaks_highlighting = none

 # Incorrect line breaks (around LINQ queries)
 resharper_bad_linq_line_breaks_highlighting = none

 # Incorrect line breaks (around parenthesis)
 resharper_bad_parens_line_breaks_highlighting = none

 # Incorrect line breaks (around statement braces)
 resharper_bad_control_braces_line_breaks_highlighting = none

 # Incorrect line breaks (line break is missing elsewhere)
 resharper_missing_linebreak_highlighting = none

 # Incorrect line breaks (line break is redundant elsewhere)
 resharper_redundant_linebreak_highlighting = none

 # Incorrect line breaks (multiple statements on one line)
 resharper_multiple_statements_on_one_line_highlighting = none

 # Incorrect line breaks (multiple type members on one line)
 resharper_multiple_type_members_on_one_line_highlighting = none

 # Incorrect spacing (around attributes)
 resharper_bad_attribute_brackets_spaces_highlighting = none

 # Incorrect spacing (around braces)
 resharper_bad_braces_spaces_highlighting = none

 # Incorrect spacing (around colon)
 resharper_bad_colon_spaces_highlighting = none

 # Incorrect spacing (around comma)
 resharper_bad_comma_spaces_highlighting = none

 # Incorrect spacing (around generic brackets)
 resharper_bad_generic_brackets_spaces_highlighting = none

 # Incorrect spacing (around member access symbols)
 resharper_bad_member_access_spaces_highlighting = none

 # Incorrect spacing (around operator symbols)
 resharper_bad_symbol_spaces_highlighting = none

 # Incorrect spacing (around parenthesis)
 resharper_bad_parens_spaces_highlighting = none

 # Incorrect spacing (around semicolon)
 resharper_bad_semicolon_spaces_highlighting = none

 # Incorrect spacing (around square brackets within a statement)
 resharper_bad_square_brackets_spaces_highlighting = none

 # Incorrect spacing (between keyword and parenthesis)
 resharper_bad_spaces_after_keyword_highlighting = none

 # Incorrect spacing (multiple spaces are prohibited)
 resharper_multiple_spaces_highlighting = none

 # Incorrect spacing (space is missing elsewhere)
 resharper_missing_space_highlighting = none

 # Incorrect spacing (space is redundant elsewhere)
 resharper_redundant_space_highlighting = none

 # Incorrect spacing (tabs are prohibited here)
 resharper_tabs_outside_indent_highlighting = none

 # Grammar error in comment
 resharper_grammar_mistake_in_comment_highlighting = none

 # Grammar error in markup attribute value
 resharper_grammar_mistake_in_markup_attribute_highlighting = none

 # Grammar error in markup text
 resharper_grammar_mistake_in_markup_text_highlighting = none

 # Grammar error in string literal
 resharper_grammar_mistake_in_string_literal_highlighting = none

 # Append to collection expression
 resharper_append_to_collection_expression_highlighting = none

 # Class cannot be instantiated
 resharper_class_cannot_be_instantiated_highlighting = none

 # Conditional expression can be rewritten as null-coalescing
 resharper_replace_conditional_expression_with_null_coalescing_highlighting = none

 # Convert 'as' expression type check and the following null check into negated pattern matching
 resharper_use_negated_pattern_matching_highlighting = none

 # Convert 'as' expression type check and the following null check into pattern matching
 resharper_use_pattern_matching_highlighting = none

 # Convert constructor into member initializers
 resharper_convert_constructor_to_member_initializers_highlighting = none

 # Convert constructor into primary constructor
 resharper_convert_to_primary_constructor_highlighting = none

 # Convert delegate variable into local function
 resharper_convert_to_local_function_highlighting = none

 # Convert 'if' statement into 'switch'
 resharper_convert_if_statement_to_switch_statement_highlighting = none

 # Convert into 'await using' statement or declaration
 resharper_use_await_using_highlighting = none

 # Convert into lambda expression
 resharper_convert_to_lambda_expression_highlighting = none

 # Convert into static class
 resharper_convert_to_static_class_highlighting = none

 # Convert into 'using' declaration
 resharper_convert_to_using_declaration_highlighting = none

 # Convert lambda expression into method group
 resharper_convert_closure_to_method_group_highlighting = none

 # Convert negated 'is' expression into 'is' expression with negated pattern
 resharper_use_negated_pattern_in_is_expression_highlighting = none

 # Convert 'Nullable<T>' into 'T?'
 resharper_convert_nullable_to_short_form_highlighting = none

 # Convert property into auto-property
 resharper_convert_to_auto_property_highlighting = none

 # Convert property into auto-property (when possible)
 resharper_convert_to_auto_property_when_possible_highlighting = none

 # Convert property into auto-property with private setter
 resharper_convert_to_auto_property_with_private_setter_highlighting = none

 # Convert static method invocation into extension method call
 resharper_invoke_as_extension_method_highlighting = none

 # Foreach loop can be converted into LINQ-expression but another 'GetEnumerator' method will be used
 resharper_foreach_can_be_converted_to_query_using_another_get_enumerator_highlighting = none

 # For-loop can be converted into foreach-loop
 resharper_for_can_be_converted_to_foreach_highlighting = none

 # 'if' statement can be rewritten as '?:' expression
 resharper_convert_if_statement_to_conditional_ternary_expression_highlighting = none

 # 'if' statement can be rewritten as '??' expression
 resharper_convert_if_statement_to_null_coalescing_expression_highlighting = none

 # 'if' statement can be rewritten as '??=' assignment
 resharper_convert_if_statement_to_null_coalescing_assignment_highlighting = none

 # 'if-return' statement can be rewritten as 'return' statement
 resharper_convert_if_statement_to_return_statement_highlighting = none

 # Inline 'out' variable declaration
 resharper_inline_out_variable_declaration_highlighting = none

 # Inline temporary variable
 resharper_inline_temporary_variable_highlighting = none

 # Introduce optional parameters (non-private accessibility)
 resharper_introduce_optional_parameters_global_highlighting = none

 # Introduce optional parameters (private accessibility)
 resharper_introduce_optional_parameters_local_highlighting = none

 # Invert 'if' statement to reduce nesting
 resharper_invert_if_highlighting = none

 # Join null check with assignment
 resharper_join_null_check_with_usage_highlighting = none

 # Lambda expression/anonymous method can be made 'static'
 resharper_lambda_expression_can_be_made_static_highlighting = none

 # Lambda expression/anonymous method must be 'static' to avoid allocations
 resharper_lambda_expression_must_be_static_highlighting = none

 # Lambda expression/anonymous method must not have captures of the containing context
 resharper_lambda_should_not_capture_context_highlighting = none

 # Literal length can be reduced by using verbatim string
 resharper_use_verbatim_string_highlighting = none

 # Loop can be converted into LINQ-expression
 resharper_loop_can_be_converted_to_query_highlighting = none

 # Merge 'and' pattern
 resharper_merge_and_pattern_highlighting = none

 # Merge conditional ?: expression into conditional access
 resharper_merge_conditional_expression_highlighting = none

 # Merge negated null/pattern checks into complex pattern
 resharper_merge_into_negated_pattern_highlighting = none

 # Merge nested property patterns
 resharper_merge_nested_property_patterns_highlighting = none

 # Merge null/pattern checks into complex pattern
 resharper_merge_into_pattern_highlighting = none

 # Merge null/pattern/value checks into 'or'/'and' patterns
 resharper_merge_into_logical_pattern_highlighting = none

 # Merge sequential checks into single conditional access check
 resharper_merge_sequential_checks_highlighting = none

 # Move to existing positional deconstruction pattern
 resharper_move_to_existing_positional_deconstruction_pattern_highlighting = none

 # Move variable declaration inside loop condition
 resharper_move_variable_declaration_inside_loop_condition_highlighting = none

 # Part of foreach loop can be converted into LINQ-expression but another 'GetEnumerator' method will be used
 resharper_foreach_can_be_partly_converted_to_query_using_another_get_enumerator_highlighting = none

 # Part of loop's body can be converted into LINQ-expression
 resharper_loop_can_be_partly_converted_to_query_highlighting = none

 # Pass string interpolation expression
 resharper_pass_string_interpolation_highlighting = none

 # Redundant accessor body
 resharper_redundant_accessor_body_highlighting = none

 # Redundant spread element
 resharper_redundant_spread_element_highlighting = none

 # Replace auto-property with computed property
 resharper_replace_auto_property_with_computed_property_highlighting = none

 # Replace if statement with null-propagating code
 resharper_use_null_propagation_highlighting = none

 # Replace object pattern not performing any additional checks with 'var' pattern
 resharper_replace_object_pattern_with_var_pattern_highlighting = none

 # Replace 'SequenceEqual' with constant pattern
 resharper_replace_sequence_equal_with_constant_pattern_highlighting = none

 # Replace 'Slice' with range indexer
 resharper_replace_slice_with_range_indexer_highlighting = none

 # Replace 'Substring' with range indexer
 resharper_replace_substring_with_range_indexer_highlighting = none

 # Replace 'switch' statement with 'switch' expression
 resharper_convert_switch_statement_to_switch_expression_highlighting = none

 # Replace ternary expression with 'switch' expression
 resharper_convert_conditional_ternary_expression_to_switch_expression_highlighting = none

 # Replace with 'field' keyword
 resharper_replace_with_field_keyword_highlighting = none

 # Replace with primary constructor parameter
 resharper_replace_with_primary_constructor_parameter_highlighting = none

 # Use alias
 resharper_use_symbol_alias_highlighting = none

 # Use collection expression syntax
 resharper_use_collection_expression_highlighting = none

 # Use compound assignment
 resharper_convert_to_compound_assignment_highlighting = none

 # Use compound assignment
 resharper_convert_to_null_coalescing_compound_assignment_highlighting = none

 # Use deconstruction
 resharper_use_deconstruction_highlighting = none

 # Use deconstruction to swap variables
 resharper_swap_via_deconstruction_highlighting = none

 # Use discard assignment
 resharper_use_discard_assignment_highlighting = none

 # Use index from end expression
 resharper_use_index_from_end_expression_highlighting = none

 # Use 'nameof' expression to reference enum member name
 resharper_use_name_of_instead_of_to_string_highlighting = none

 # Use 'nameof' expression to reference name
 resharper_use_nameof_expression_highlighting = none

 # Use 'nameof' expression to reference name in part of the string literal
 resharper_use_nameof_expression_for_part_of_the_string_highlighting = none

 # Use 'nameof' expression to reference type name
 resharper_use_name_of_instead_of_type_of_highlighting = none

 # Use 'nameof' expression when registering a DependencyProperty
 resharper_use_nameof_for_dependency_property_highlighting = none

 # Use object or collection initializer when possible
 resharper_use_object_or_collection_initializer_highlighting = none

 # Use positional deconstruction pattern
 resharper_use_positional_deconstruction_pattern_highlighting = none

 # Use raw string
 resharper_use_raw_string_highlighting = none

 # Use string interpolation expression
 resharper_use_string_interpolation_highlighting = none

 # Use type annotation syntax
 resharper_use_nullable_reference_types_annotation_syntax_highlighting = none

 # Use unsigned right shift operator '>>>'
 resharper_use_unsigned_right_shift_operator_highlighting = none

 # Use UTF-8 string literal
 resharper_use_utf8_string_literal_highlighting = none

 # Use 'with' expression to copy anonymous object
 resharper_use_with_expression_to_copy_anonymous_object_highlighting = none

 # Use 'with' expression to copy record
 resharper_use_with_expression_to_copy_record_highlighting = none

 # Use 'with' expression to copy struct
 resharper_use_with_expression_to_copy_struct_highlighting = none

 # Use 'with' expression to copy tuple
 resharper_use_with_expression_to_copy_tuple_highlighting = none

 # NUnit. Async test method must return Task or Task<T>
 resharper_n_unit_async_method_must_be_task_highlighting = none

 # NUnit. Duplicate values.
 resharper_n_unit_duplicate_values_highlighting = none

 # NUnit. Ignored parameter attribute.
 resharper_n_unit_ignored_parameter_attribute_highlighting = none

 # NUnit. Implicitly unspecified null values.
 resharper_n_unit_implicit_unspecified_null_values_highlighting = none

 # NUnit. Incompatible argument type or incorrect argument value.
 resharper_n_unit_incorrect_argument_type_highlighting = none

 # NUnit. Incompatible expected result type or incorrect value.
 resharper_n_unit_incorrect_expected_result_type_highlighting = none

 # NUnit. Incorrect range bounds. 'to' must be greater than or equal to 'from'.
 resharper_n_unit_incorrect_range_bounds_highlighting = none

 # NUnit. Mismatch of the range step sign.
 resharper_n_unit_range_step_sign_mismatch_highlighting = none

 # NUnit. Missing arguments in TestCase attribute.
 resharper_n_unit_missing_arguments_in_test_case_attribute_highlighting = none

 # NUnit. Missing 'CancelAfter' attribute on test method declaration.
 resharper_n_unit_missing_cancel_after_attribute_highlighting = none

 # NUnit. Missing expected result for non-void test method.
 resharper_n_unit_test_case_attribute_requires_expected_result_highlighting = none

 # NUnit. No values provided in the attributes.
 resharper_n_unit_no_values_provided_highlighting = none

 # NUnit. Non-public test method.
 resharper_n_unit_non_public_method_with_test_attribute_highlighting = none

 # NUnit. Range 'step' parameter value must be non-zero.
 resharper_n_unit_range_step_value_must_not_be_zero_highlighting = none

 # NUnit. Redundant argument in TestCase attribute.
 resharper_n_unit_redundant_argument_in_test_case_attribute_highlighting = none

 # NUnit. Redundant argument instead of ExpectedResult.
 resharper_n_unit_redundant_argument_instead_of_expected_result_highlighting = none

 # NUnit. Redundant expected result for void test method.
 resharper_n_unit_redundant_expected_result_in_test_case_attribute_highlighting = none

 # NUnit. Specified attribute values produce too many tests.
 resharper_n_unit_attribute_produces_too_many_tests_highlighting = none

 # NUnit. Specified values are not compatible with the test parameter type.
 resharper_n_unit_parameter_type_is_not_compatible_with_attribute_highlighting = none

 # NUnit. Test case Result property duplicates ExpectedResult.
 resharper_n_unit_test_case_result_property_duplicates_expected_result_highlighting = none

 # NUnit. Test case Result property is obsolete.
 resharper_n_unit_test_case_result_property_is_obsolete_highlighting = none

 # NUnit. Test case source must be field, property, or method.
 resharper_n_unit_test_case_source_must_be_field_property_method_highlighting = none

 # NUnit. Test case source must be non-abstract and implement IEnumerable.
 resharper_n_unit_test_case_source_should_implement_i_enumerable_highlighting = none

 # NUnit. Test case source must be static.
 resharper_n_unit_test_case_source_must_be_static_highlighting = none

 # NUnit. The maximum range value is not reachable with the step value.
 resharper_n_unit_range_to_value_is_not_reachable_highlighting = none

 # NUnit. Values for test method parameters are not provided.
 resharper_n_unit_method_with_parameters_and_test_attribute_highlighting = none

 # NUnit. Values in range do not fit the type of the test parameter.
 resharper_n_unit_range_attribute_bounds_are_out_of_range_highlighting = none

 # NUnit.AutoFixture. Incompatible argument type or incorrect argument value.
 resharper_n_unit_auto_fixture_incorrect_argument_type_highlighting = none

 # NUnit.AutoFixture. Missing Test or TestFixture attribute.
 resharper_n_unit_auto_fixture_missed_test_or_test_fixture_attribute_highlighting = none

 # NUnit.AutoFixture. Redundant argument in InlineAutoData attribute.
 resharper_n_unit_auto_fixture_redundant_argument_in_inline_auto_data_attribute_highlighting = none

 # '?:' expression has identical true and false branches
 resharper_conditional_ternary_equal_branch_highlighting = none

 # [MustDisposeResource] annotation is not inherited from the base constructor and should be placed explicitly
 resharper_constructor_with_must_dispose_resource_attribute_base_is_not_annotated_highlighting = none

 # [ThreadStatic] does not work with instance fields
 resharper_thread_static_at_instance_field_highlighting = none

 # A suppressed nullable warning might hide an underlying problem
 resharper_nullable_warning_suppression_is_used_highlighting = none

 # Abstract or virtual (overridable) event is never invoked
 resharper_event_never_invoked_global_highlighting = none

 # Access to disposed captured variable
 resharper_access_to_disposed_closure_highlighting = none

 # Access to foreach variable in closure
 resharper_access_to_for_each_variable_in_closure_highlighting = none

 # Access to modified captured variable
 resharper_access_to_modified_closure_highlighting = none

 # According to values of the bit masks, expression result will always be the same
 resharper_non_constant_equality_expression_has_constant_result_highlighting = none

 # Actual shift count equals zero
 resharper_shift_expression_real_shift_count_is_zero_highlighting = none

 # Ambiguous symbols in text argument
 resharper_multiple_resolve_candidates_in_text_highlighting = none

 # Annotation conflict in hierarchy
 resharper_annotation_conflict_in_hierarchy_highlighting = none

 # Assignment in conditional expression
 resharper_assignment_in_conditional_expression_highlighting = none

 # Async iterator invocation without 'await foreach'
 resharper_async_iterator_invocation_without_await_foreach_highlighting = none

 # Auto-property accessor is never used (non-private accessibility)
 resharper_unused_auto_property_accessor_global_highlighting = none

 # Auto-property accessor is never used (private accessibility)
 resharper_unused_auto_property_accessor_local_highlighting = none

 # Avoid mixing of variable-length escape sequences and text
 resharper_variable_length_string_hex_escape_sequence_highlighting = none

 # Avoid using 'async' for methods and functions with the 'void' return type
 resharper_async_void_method_highlighting = none

 # Avoid using 'async' lambda when delegate type returns 'void'
 resharper_async_void_lambda_highlighting = none

 # Backing field is assigned but never used
 resharper_property_field_keyword_is_never_used_highlighting = none

 # Backing field is used but never assigned
 resharper_property_field_keyword_is_never_assigned_highlighting = none

 # Bitwise operation on enum that is not marked by the [Flags] attribute
 resharper_bitwise_operator_on_enum_without_flags_highlighting = none

 # Call to base member with implicit default parameters
 resharper_base_method_call_with_default_parameter_highlighting = none

 # Call to 'base.Equals(...)' is reference equality
 resharper_base_object_equals_is_object_equals_highlighting = none

 # Cannot access static symbol in text argument
 resharper_static_problem_in_text_highlighting = none

 # Cannot access symbol in text argument
 resharper_access_rights_in_text_highlighting = none

 # Cannot resolve property
 resharper_property_not_resolved_highlighting = none

 # Cannot resolve resource
 resharper_resource_not_resolved_highlighting = none

 # Cannot resolve resource item
 resharper_resource_item_not_resolved_highlighting = none

 # Cannot resolve symbol in text argument
 resharper_not_resolved_in_text_highlighting = none

 # Captured field reference of a marshal-by-reference class may cause a runtime exception
 resharper_address_of_marshal_by_ref_object_highlighting = none

 # Captured primary constructor parameter is mutable
 resharper_captured_primary_constructor_parameter_is_mutable_highlighting = none

 # Captured reference to 'volatile' field will not be treated as 'volatile'
 resharper_by_ref_argument_is_volatile_field_highlighting = none

 # Char is possibly unintentionally used as integer
 resharper_confusing_char_as_integer_in_constructor_highlighting = none

 # Class is never instantiated (non-private accessibility)
 resharper_class_never_instantiated_global_highlighting = none

 # Class is never instantiated (private accessibility)
 resharper_class_never_instantiated_local_highlighting = none

 # Collection content is never queried (non-private accessibility)
 resharper_collection_never_queried_global_highlighting = none

 # Collection content is never queried (private accessibility)
 resharper_collection_never_queried_local_highlighting = none

 # Collection is never updated (non-private accessibility)
 resharper_collection_never_updated_global_highlighting = none

 # Collection is never updated (private accessibility)
 resharper_collection_never_updated_local_highlighting = none

 # Constant shift expression with non-zero operands results in a zero value
 resharper_shift_expression_result_equals_zero_highlighting = none

 # Co-variant array conversion
 resharper_co_variant_array_conversion_highlighting = none

 # Disposal of a variable already captured by the 'using' statement
 resharper_dispose_on_using_variable_highlighting = none

 # Division by zero in at least one execution path
 resharper_int_division_by_zero_highlighting = none

 # Do not store SpinLock in readonly field
 resharper_spin_lock_in_readonly_field_highlighting = none

 # Do not use object initializer for 'using' variable
 resharper_using_statement_resource_initialization_highlighting = none

 # Do not use object initializer for 'using' variable (object initializer expression may throw exception while initializing 'using' variable)
 resharper_using_statement_resource_initialization_expression_highlighting = none

 # Do not use right brace after a format specifier in format strings
 resharper_format_specifier_captures_right_braces_highlighting = none

 # Duplicate keys in dictionary/set initialization
 resharper_duplicate_key_collection_initialization_highlighting = none

 # Duplicated chained 'if' branches
 resharper_duplicated_chained_if_bodies_highlighting = none

 # Duplicated sequential 'if' branches
 resharper_duplicated_sequential_if_bodies_highlighting = none

 # Duplicated switch branches
 resharper_duplicated_switch_section_bodies_highlighting = none

 # Element is localizable
 resharper_localizable_element_highlighting = none

 # Empty general catch clause
 resharper_empty_general_catch_clause_highlighting = none

 # Empty 'with' expression is redundant
 resharper_redundant_with_expression_highlighting = none

 # 'Enumerable.Sum' invocation in explicit unchecked context
 resharper_enumerable_sum_in_explicit_unchecked_context_highlighting = none

 # Equality comparison of floating point numbers
 resharper_compare_of_floats_by_equality_operator_highlighting = none

 # Escape sequence can be simplified
 resharper_can_simplify_string_escape_sequence_highlighting = none

 # Event is never subscribed to (non-private accessibility)
 resharper_event_never_subscribed_to_global_highlighting = none

 # Event is never subscribed to (private accessibility)
 resharper_event_never_subscribed_to_local_highlighting = none

 # Event never invoked
 resharper_event_never_invoked_highlighting = none

 # Event unsubscription via anonymous delegate
 resharper_event_unsubscription_via_anonymous_delegate_highlighting = none

 # Exception rethrow possibly intended
 resharper_possible_intended_rethrow_highlighting = none

 # Explicit argument passed to parameter with caller info attribute
 resharper_explicit_caller_info_argument_highlighting = none

 # Extract common code
 resharper_extract_common_branching_code_highlighting = none

 # Field hides property with default implementation in interface
 resharper_field_hides_interface_property_with_default_implementation_highlighting = none

 # Formatting is specified, but interpolated string expression is not IFormattable
 resharper_interpolated_string_expression_is_not_i_formattable_highlighting = none

 # Function body is too complex to analyze
 resharper_function_complexity_overflow_highlighting = none

 # Function is recursive on all execution paths
 resharper_function_recursive_on_all_paths_highlighting = none

 # Function never returns
 resharper_function_never_returns_highlighting = none

 # 'GC.SuppressFinalize' is invoked for type without destructor
 resharper_gc_suppress_finalize_for_type_without_destructor_highlighting = none

 # Heuristically unreachable case according to integer analysis
 resharper_unreachable_switch_case_due_to_integer_analysis_highlighting = none

 # Heuristically unreachable switch arm according to integer analysis
 resharper_unreachable_switch_arm_due_to_integer_analysis_highlighting = none

 # Inconsistent arguments passed to 'Math.Clamp()' method
 resharper_math_clamp_min_greater_than_max_highlighting = none

 # Inconsistent order of taken locks
 resharper_inconsistent_order_of_locks_highlighting = none

 # Inconsistent synchronization on field
 resharper_inconsistently_synchronized_field_highlighting = none

 # Index from end must be greater than zero; use '^1' to refer to the last element
 resharper_zero_index_from_end_highlighting = none

 # Interfaces marked as ServiceContract should declare at least one OperationContract
 resharper_service_contract_without_operations_highlighting = none

 # Invalid XML documentation comment
 resharper_invalid_xml_doc_comment_highlighting = none

 # Invocation of polymorphic field-like event
 resharper_polymorphic_field_like_event_invocation_highlighting = none

 # IQueryable is possibly unintentionally used as IEnumerable
 resharper_possible_unintended_queryable_as_enumerable_highlighting = none

 # Iterator never returns
 resharper_iterator_never_returns_highlighting = none

 # Local function hides method
 resharper_local_function_hides_method_highlighting = none

 # Local variable hides member
 resharper_local_variable_hides_member_highlighting = none

 # Local variable hides primary constructor parameter
 resharper_local_variable_hides_primary_constructor_parameter_highlighting = none

 # Loop control variable is never changed inside loop
 resharper_loop_variable_is_never_changed_inside_loop_highlighting = none

 # Meaningless [HandlesResourceDisposal] annotation for an output parameter
 resharper_out_parameter_with_handles_resource_disposal_attribute_highlighting = none

 # Meaningless [MustDisposeResource] annotation for an input parameter
 resharper_in_parameter_with_must_dispose_resource_attribute_highlighting = none

 # Member hides static member from outer class
 resharper_member_hides_static_from_outer_class_highlighting = none

 # Member initialized value ignored
 resharper_member_initializer_value_ignored_highlighting = none

 # Method is marked as OperationContract but containing type is not marked as ServiceContract
 resharper_operation_contract_without_service_contract_highlighting = none

 # Method with optional or 'params' parameter is hidden by overload
 resharper_method_overload_with_optional_parameter_highlighting = none

 # Mismatch of optional parameter value in overridden method
 resharper_optional_parameter_hierarchy_mismatch_highlighting = none

 # Missing '.ConfigureAwait(false)' for async disposable in library code
 resharper_use_configure_await_false_for_async_disposable_highlighting = none

 # Missing '.ConfigureAwait(false)' in library code
 resharper_use_configure_await_false_highlighting = none

 # Multiple sequential 'OrderBy' invocation
 resharper_multiple_order_by_highlighting = none

 # Non-accessed field (non-private accessibility)
 resharper_not_accessed_field_global_highlighting = none

 # Non-accessed field (private accessibility)
 resharper_not_accessed_field_local_highlighting = none

 # Non-accessed positional property (non-private accessibility)
 resharper_not_accessed_positional_property_global_highlighting = none

 # Non-accessed positional property (private accessibility)
 resharper_not_accessed_positional_property_local_highlighting = none

 # Non-public member in implementation class hides default implementation in interface
 resharper_member_hides_interface_member_with_default_implementation_highlighting = none

 # Non-readonly type member referenced in 'GetHashCode()'
 resharper_non_readonly_member_in_get_hash_code_highlighting = none

 # Nullability conflicts with annotations in hierarchy
 resharper_nullness_annotation_conflict_with_jet_brains_annotations_highlighting = none

 # Nullable warning suppression operator might be confused with inverted 'is' expression
 resharper_suppress_nullable_warning_expression_as_inverted_is_expression_highlighting = none

 # 'Object.ReferenceEquals' is always false because it is called with value type
 resharper_reference_equals_with_value_type_highlighting = none

 # One way operations must not return values
 resharper_one_way_operation_contract_with_return_type_highlighting = none

 # Operator 'is'/'Type Of ... Is ...' can be used
 resharper_operator_is_can_be_used_highlighting = none

 # Operator without matching checked operator
 resharper_operator_without_matched_checked_operator_highlighting = none

 # Overridden GetHashCode calls base 'Object.GetHashCode()'
 resharper_base_object_get_hash_code_call_in_get_hash_code_highlighting = none

 # Parameter hides member
 resharper_parameter_hides_member_highlighting = none

 # Parameter hides primary constructor parameter
 resharper_parameter_hides_primary_constructor_parameter_highlighting = none

 # Parameter name differs between partial member declarations
 resharper_partial_method_parameter_name_mismatch_highlighting = none

 # Possible ambiguity while accessing member by interface
 resharper_possible_interface_member_ambiguity_highlighting = none

 # Possible comparison of value type with 'null'
 resharper_compare_non_constrained_generic_with_null_highlighting = none

 # Possible cyclic constructor call
 resharper_constructor_initializer_loop_highlighting = none

 # Possible incorrect implementation of Double-Check Locking pattern. Possible multiple write access to checked field.
 resharper_possible_multiple_write_access_in_double_check_locking_highlighting = none

 # Possible incorrect implementation of Double-Check Locking pattern. Read access to checked field.
 resharper_read_access_in_double_check_locking_highlighting = none

 # Possible infinite inheritance
 resharper_possible_infinite_inheritance_highlighting = none

 # Possible loss of fraction
 resharper_possible_loss_of_fraction_highlighting = none

 # Possible mistaken argument of type 'System.Type'
 resharper_possible_mistaken_system_type_argument_highlighting = none

 # Possible mistaken 'GetType()' invocation
 resharper_possible_mistaken_call_to_get_type_highlighting = none

 # Possible multiple enumeration
 resharper_possible_multiple_enumeration_highlighting = none

 # Possible overflow
 resharper_int_variable_overflow_highlighting = none

 # Possible overflow in checked context
 resharper_int_variable_overflow_in_checked_context_highlighting = none

 # Possible overflow in unchecked context
 resharper_int_variable_overflow_in_unchecked_context_highlighting = none

 # Possible 'System.ArgumentOutOfRangeException'. Index must be a non-negative integer.
 resharper_negative_index_highlighting = none

 # Possible 'System.ArgumentOutOfRangeException'. Start index must be less than or equal to end index.
 resharper_indexing_by_invalid_range_highlighting = none

 # Possible 'System.InvalidCastException'
 resharper_possible_invalid_cast_exception_highlighting = none

 # Possible 'System.InvalidCastException' in foreach loop
 resharper_possible_invalid_cast_exception_in_foreach_loop_highlighting = none

 # Possible 'System.InvalidOperationException'
 resharper_possible_invalid_operation_exception_highlighting = none

 # Possible 'System.InvalidOperationException: Collection was modified'
 resharper_possible_invalid_operation_exception_collection_was_modified_highlighting = none

 # Possible 'System.NullReferenceException'
 resharper_possible_null_reference_exception_highlighting = none

 # Possible unassigned object created by 'new' expression
 resharper_object_creation_as_statement_highlighting = none

 # Possible unintended reference comparison
 resharper_possible_unintended_reference_comparison_highlighting = none

 # Possibly impure struct method is called on readonly variable: struct value always copied before invocation
 resharper_possibly_impure_method_call_on_readonly_variable_highlighting = none

 # Possibly misleading 'DefaultValueAttribute' usage to define optional parameter value
 resharper_default_value_attribute_for_optional_parameter_highlighting = none

 # Possibly missing comma before indexer initializer
 resharper_possibly_missing_indexer_initializer_comma_highlighting = none

 # Possibly mistaken use of a 'CancellationToken'
 resharper_possibly_mistaken_use_of_cancellation_token_highlighting = none

 # Possibly unintended linear search in set
 resharper_possible_unintended_linear_search_in_set_highlighting = none

 # Possibly unintended modification inside conditional invocation
 resharper_possibly_unintended_side_effects_inside_conditional_invocation_highlighting = none

 # Possibly unintended string interpolation instead of format string template
 resharper_possibly_mistaken_use_of_interpolated_string_insert_highlighting = none

 # Possibly wrong string comparison: spans are only equal when pointing to the same memory location
 resharper_string_span_comparison_highlighting = none

 # Potentially misleading parameter name in lambda or local function
 resharper_all_underscore_local_parameter_name_highlighting = none

 # Prefer explicitly provided tuple component name
 resharper_prefer_explicitly_provided_tuple_component_name_highlighting = none

 # Primary constructor parameter capturing is disallowed
 resharper_primary_constructor_parameter_capture_disallowed_highlighting = none

 # 'ref' or 'out' parameter with [Optional] attribute
 resharper_optional_parameter_ref_out_highlighting = none

 # Return of a task produced by 'using'-captured object
 resharper_return_of_task_produced_by_using_variable_highlighting = none

 # Return of a variable captured by 'using' statement
 resharper_return_of_using_variable_highlighting = none

 # Return type of a function can be made non-nullable
 resharper_return_type_can_be_not_nullable_highlighting = none

 # Return value of [MustUseReturnValue]-annotated method is not used
 resharper_must_use_return_value_highlighting = none

 # Return value of a method annotated with [MustDisposeResource] is never disposed
 resharper_not_disposed_resource_highlighting = none

 # Return value of a property must be disposed by the callee
 resharper_not_disposed_resource_is_returned_by_property_highlighting = none

 # Return value of 'GetEnumerator' method call is never disposed
 resharper_generic_enumerator_not_disposed_highlighting = none

 # Return value of iterator is not used
 resharper_iterator_method_result_is_ignored_highlighting = none

 # Return value of pure method is not used
 resharper_return_value_of_pure_method_is_not_used_highlighting = none

 # Return value should be disposed but the method or function is not annotated with [MustDisposeResource]
 resharper_not_disposed_resource_is_returned_highlighting = none

 # Safe cast expression always succeeds
 resharper_try_cast_always_succeeds_highlighting = none

 # Shift expression with zero left operand equals zero
 resharper_shift_expression_zero_left_operand_highlighting = none

 # Similar anonymous type detected nearby
 resharper_similar_anonymous_type_nearby_highlighting = none

 # Similar expressions comparison
 resharper_equal_expression_comparison_highlighting = none

 # Some values of the enum are not processed inside 'switch' expression and are handled via exception in default arm
 resharper_switch_expression_handles_some_known_enum_values_with_exception_in_default_highlighting = none

 # Some values of the enum are not processed inside 'switch' statement
 resharper_switch_statement_missing_some_enum_cases_no_default_highlighting = none

 # Some values of the enum are not processed inside 'switch' statement and are handled via default section
 resharper_switch_statement_handles_some_known_enum_values_with_default_highlighting = none

 # Static field or auto-property in generic type
 resharper_static_member_in_generic_type_highlighting = none

 # Static member initializer refers to static member below or in other part
 resharper_static_member_initializer_referes_to_member_below_highlighting = none

 # String formatting method problems
 resharper_format_string_problem_highlighting = none

 # Structured message template problems
 resharper_structured_message_template_problem_highlighting = none

 # Suspicious locking over synchronization primitive
 resharper_suspicious_lock_over_synchronization_primitive_highlighting = none

 # Suspicious parameter name in ArgumentNullException
 resharper_suspicious_parameter_name_in_argument_null_exception_highlighting = none

 # Suspicious shift count for this type of left operand
 resharper_shift_expression_right_operand_not_equal_real_count_highlighting = none

 # Suspicious type conversion or check
 resharper_suspicious_type_conversion_global_highlighting = none

 # Suspicious use of variable with discard-like name
 resharper_assignment_instead_of_discard_highlighting = none

 # Suspicious 'volatile' field usage: compound operation is not atomic. 'Interlocked' class can be used instead.
 resharper_non_atomic_compound_operator_highlighting = none

 # Symbol from module that might be missing at runtime
 resharper_symbol_from_not_copied_locally_reference_used_warning_highlighting = none

 # Tail recursive call can be replaced with loop
 resharper_tail_recursive_call_highlighting = none

 # The expression of 'is' operator is never of the provided type
 resharper_is_expression_always_false_highlighting = none

 # The given expression of 'is' operator is always of the provided type
 resharper_is_expression_always_true_highlighting = none

 # The logging message template should not vary between calls to a logging method
 resharper_non_static_logger_template_highlighting = none

 # The pattern is redundant, it does not produce any runtime checks
 resharper_pattern_is_redundant_highlighting = none

 # The source expression always matches the provided pattern
 resharper_pattern_always_matches_highlighting = none

 # The source expression never matches the provided pattern
 resharper_pattern_never_matches_highlighting = none

 # Thread static field has initializer
 resharper_thread_static_field_has_initializer_highlighting = none

 # Try cast and check for null can be replaced with a type check
 resharper_safe_cast_is_used_as_type_check_highlighting = none

 # Type check and casts can be merged
 resharper_merge_cast_with_type_check_highlighting = none

 # Type pattern and casts can be merged
 resharper_use_switch_case_pattern_variable_highlighting = none

 # Unassigned field (non-private accessibility)
 resharper_unassigned_field_global_highlighting = none

 # Unassigned field (private accessibility)
 resharper_unassigned_field_local_highlighting = none

 # Unassigned readonly field
 resharper_unassigned_readonly_field_highlighting = none

 # Unknown Razor layout
 resharper_razor_layout_not_resolved_highlighting = none

 # Unknown Razor section
 resharper_razor_section_not_resolved_highlighting = none

 # Usage of <inheritdoc /> is invalid
 resharper_inheritdoc_invalid_usage_highlighting = none

 # Use <inheritdoc /> on root level to inherit documentation from base candidate
 resharper_inheritdoc_consider_usage_highlighting = none

 # Use collection's count property
 resharper_use_collection_count_property_highlighting = none

 # Use format specifier in format strings
 resharper_use_format_specifier_in_format_string_highlighting = none

 # Use format specifier in interpolated strings
 resharper_simplify_string_interpolation_highlighting = none

 # Use null check instead of a type check succeeding on any not-null value
 resharper_convert_type_check_to_null_check_highlighting = none

 # Use null check pattern instead of a type check succeeding on any not-null value
 resharper_convert_type_check_pattern_to_null_check_highlighting = none

 # Use nullable annotation instead of an attribute
 resharper_use_nullable_annotation_instead_of_attribute_highlighting = none

 # Useless arithmetical operation
 resharper_useless_binary_operation_highlighting = none

 # Using stackalloc inside loop
 resharper_stack_alloc_inside_loop_highlighting = none

 # Value assigned to a property of non-variable qualifier expression can be lost
 resharper_possible_struct_member_modification_of_non_variable_struct_highlighting = none

 # 'value' parameter is not used
 resharper_value_parameter_not_used_highlighting = none

 # Variable can be declared as non-nullable
 resharper_variable_can_be_not_nullable_highlighting = none

 # Variable in local function hides variable from outer scope
 resharper_variable_hides_outer_variable_highlighting = none

 # Virtual member call in constructor
 resharper_virtual_member_call_in_constructor_highlighting = none

 # 'void' method is annotated with the [MustDisposeResource] attribute
 resharper_void_method_with_must_dispose_resource_attribute_highlighting = none

 # 'void' method is annotated with the [MustUseReturnValue] attribute
 resharper_void_method_with_must_use_return_value_attribute_highlighting = none

 # 'void' method is annotated with the [Pure] attribute
 resharper_pure_attribute_on_void_method_highlighting = none

 # 'with' expression is used instead of object initializer
 resharper_with_expression_instead_of_initializer_highlighting = none

 # 'with' expression modifies all accessible instance members
 resharper_with_expression_modifies_all_members_highlighting = none

 # '??' condition is known to be null or not null
 resharper_constant_null_coalescing_condition_highlighting = none

 # '??' condition is never null according to nullable reference types' annotations
 resharper_null_coalescing_condition_is_always_not_null_according_to_api_contract_highlighting = none

 # [NotNull] or [CanBeNull] attribute is applied to a type that already has the same annotation from nullable reference types
 resharper_redundant_nullness_attribute_with_nullable_reference_types_highlighting = none

 # Anonymous method signature is not necessary
 resharper_unused_anonymous_method_signature_highlighting = none

 # Array creation can be replaced with array initializer
 resharper_redundant_array_creation_expression_highlighting = none

 # Assignment is not used
 resharper_redundant_assignment_highlighting = none

 # Assignment results are fully discarded
 resharper_assignment_is_fully_discarded_highlighting = none

 # Comparison to integral constant is useless
 resharper_useless_comparison_to_integral_constant_highlighting = none

 # Conditional access qualifier expression is known to be null or not null
 resharper_constant_conditional_access_qualifier_highlighting = none

 # Conditional access qualifier expression is not null according to nullable reference types' annotations
 resharper_conditional_access_qualifier_is_non_nullable_according_to_api_contract_highlighting = none

 # 'ContainsKey' call is redundant before adding the item to the dictionary
 resharper_redundant_dictionary_contains_key_before_adding_highlighting = none

 # Double negation operator
 resharper_double_negation_operator_highlighting = none

 # Duplicated statements
 resharper_duplicated_statements_highlighting = none

 # Empty 'for' loop is redundant
 resharper_empty_for_statement_highlighting = none

 # Empty region
 resharper_empty_region_highlighting = none

 # Explicit delegate creation expression is redundant
 resharper_redundant_delegate_creation_highlighting = none

 # Expression is always 'null'
 resharper_expression_is_always_null_highlighting = none

 # Expression is always 'true' or always 'false'
 resharper_condition_is_always_true_or_false_highlighting = none

 # Expression is always 'true' or 'false' according to nullable reference types' annotations
 resharper_condition_is_always_true_or_false_according_to_nullable_api_contract_highlighting = none

 # Heuristically unreachable code
 resharper_heuristic_unreachable_code_highlighting = none

 # Immediate delegate invocation
 resharper_redundant_immediate_delegate_invocation_highlighting = none

 # Math.Abs() argument is always non-negative
 resharper_math_abs_method_is_redundant_highlighting = none

 # Math.Sign() method always gives the same result
 resharper_suspicious_math_sign_method_highlighting = none

 # Parentheses are redundant if attribute has no arguments
 resharper_redundant_attribute_parentheses_highlighting = none

 # Pattern is always 'true' or always 'false'
 resharper_pattern_is_always_true_or_false_highlighting = none

 # Private field can be converted into local variable
 resharper_private_field_can_be_converted_to_local_variable_highlighting = none

 # Raw string can be simplified
 resharper_raw_string_can_be_simplified_highlighting = none

 # Redundant [AttributeUsage] attribute property assignment
 resharper_redundant_attribute_usage_property_highlighting = none

 # Redundant 'abstract' modifier
 resharper_redundant_abstract_modifier_highlighting = none

 # Redundant anonymous type property explicit name
 resharper_redundant_anonymous_type_property_name_highlighting = none

 # Redundant argument passed to caller argument expression parameter
 resharper_redundant_caller_argument_expression_default_value_highlighting = none

 # Redundant argument with default value
 resharper_redundant_argument_default_value_highlighting = none

 # Redundant arithmetic overflow checking context
 resharper_redundant_overflow_checking_context_highlighting = none

 # Redundant 'Attribute' suffix
 resharper_redundant_attribute_suffix_highlighting = none

 # Redundant 'base.' qualifier
 resharper_redundant_base_qualifier_highlighting = none

 # Redundant boolean comparison
 resharper_redundant_bool_compare_highlighting = none

 # Redundant braces in collection initializer
 resharper_redundant_collection_initializer_element_braces_highlighting = none

 # Redundant 'case' label
 resharper_redundant_case_label_highlighting = none

 # Redundant 'case' label before default section
 resharper_redundant_enum_case_label_for_default_section_highlighting = none

 # Redundant cast
 resharper_redundant_cast_highlighting = none

 # Redundant catch clause
 resharper_redundant_catch_clause_highlighting = none

 # Redundant 'class' keyword in record declaration
 resharper_redundant_record_class_keyword_highlighting = none

 # Redundant collection copy
 resharper_redundant_collection_copy_call_highlighting = none

 # Redundant condition check before assignments
 resharper_redundant_check_before_assignment_highlighting = none

 # Redundant conditional ternary expression usage
 resharper_redundant_ternary_expression_highlighting = none

 # Redundant context capturing with 'ConfigureAwait'
 resharper_redundant_configure_await_highlighting = none

 # Redundant control flow jump statement
 resharper_redundant_jump_statement_highlighting = none

 # Redundant discard designation
 resharper_redundant_discard_designation_highlighting = none

 # Redundant 'else' keyword
 resharper_redundant_if_else_block_highlighting = none

 # Redundant empty argument list on object creation expression
 resharper_redundant_empty_object_creation_argument_list_highlighting = none

 # Redundant empty finally block
 resharper_redundant_empty_finally_block_highlighting = none

 # Redundant empty object or collection initializer
 resharper_redundant_empty_object_or_collection_initializer_highlighting = none

 # Redundant empty switch section
 resharper_redundant_empty_switch_section_highlighting = none

 # Redundant explicit collection creation in argument of 'params' parameter
 resharper_redundant_explicit_params_array_creation_highlighting = none

 # Redundant explicit nullable type creation
 resharper_redundant_explicit_nullable_creation_highlighting = none

 # Redundant explicit positional property declaration
 resharper_redundant_explicit_positional_property_declaration_highlighting = none

 # Redundant explicit size specification in array creation
 resharper_redundant_explicit_array_size_highlighting = none

 # Redundant explicit tuple component name
 resharper_redundant_explicit_tuple_component_name_highlighting = none

 # Redundant explicit type in array creation
 resharper_redundant_explicit_array_creation_highlighting = none

 # Redundant fixed pointer declaration
 resharper_redundant_fixed_pointer_declaration_highlighting = none

 # Redundant global using directive
 resharper_redundant_using_directive_global_highlighting = none

 # Redundant 'IEnumerable.Cast<T>' or 'IEnumerable.OfType<T>' call
 resharper_redundant_enumerable_cast_call_highlighting = none

 # Redundant lambda expression parameter type specification
 resharper_redundant_lambda_parameter_type_highlighting = none

 # Redundant lambda signature parentheses
 resharper_redundant_lambda_signature_parentheses_highlighting = none

 # Redundant name qualifier
 resharper_redundant_name_qualifier_highlighting = none

 # Redundant 'notnull' constraint on type parameter constrained by non-nullable base type
 resharper_redundant_not_null_constraint_highlighting = none

 # Redundant nullable annotation on base type constraint of type parameter constrained by another non-nullable base type
 resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_base_type_highlighting = none

 # Redundant nullable annotation on base type constraint of type parameter having non-nullable type kind
 resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_type_kind_highlighting = none

 # Redundant nullable annotation on 'class?' constraint of type parameter constrained by non-nullable base type
 resharper_redundant_nullable_annotation_on_reference_type_constraint_highlighting = none

 # Redundant nullable attribute
 resharper_redundant_nullable_flow_attribute_highlighting = none

 # Redundant nullable directive
 resharper_redundant_nullable_directive_highlighting = none

 # Redundant nullable warning suppression expression
 resharper_redundant_suppress_nullable_warning_expression_highlighting = none

 # Redundant 'object.ToString()' call
 resharper_redundant_to_string_call_highlighting = none

 # Redundant 'object.ToString()' call for value types
 resharper_redundant_to_string_call_for_value_type_highlighting = none

 # Redundant operand in logical conditional expression
 resharper_redundant_logical_conditional_expression_operand_highlighting = none

 # Redundant 'orderby' clause 'ascending' keyword
 resharper_redundant_query_order_by_ascending_keyword_highlighting = none

 # Redundant property pattern clause
 resharper_redundant_property_pattern_clause_highlighting = none

 # Redundant range bound
 resharper_redundant_range_bound_highlighting = none

 # Redundant 'readonly' modifier
 resharper_redundant_readonly_modifier_highlighting = none

 # Redundant 'scoped' parameter modifier
 resharper_redundant_scoped_parameter_modifier_highlighting = none

 # Redundant semicolon after type or namespace declaration
 resharper_redundant_declaration_semicolon_highlighting = none

 # Redundant string interpolation
 resharper_redundant_string_interpolation_highlighting = none

 # Redundant 'string.Format()' call
 resharper_redundant_string_format_call_highlighting = none

 # Redundant 'string.ToCharArray()' call
 resharper_redundant_string_to_char_array_call_highlighting = none

 # Redundant switch expression arms
 resharper_redundant_switch_expression_arms_highlighting = none

 # Redundant type arguments inside 'nameof'
 resharper_redundant_type_arguments_inside_nameof_highlighting = none

 # Redundant type arguments of method
 resharper_redundant_type_arguments_of_method_highlighting = none

 # Redundant type check in a pattern
 resharper_redundant_type_check_in_pattern_highlighting = none

 # Redundant type declaration body
 resharper_redundant_type_declaration_body_highlighting = none

 # Redundant using directive
 resharper_redundant_using_directive_highlighting = none

 # Redundant verbatim prefix
 resharper_redundant_verbatim_prefix_highlighting = none

 # Redundant verbatim string prefix
 resharper_redundant_verbatim_string_prefix_highlighting = none

 # Redundant 'virtual' modifier
 resharper_redundant_virtual_modifier_highlighting = none

 # Redundant 'WithCancellation()' invocation
 resharper_redundant_with_cancellation_highlighting = none

 # Remove redundant pattern-matching parentheses
 resharper_redundant_pattern_parentheses_highlighting = none

 # Subpattern that always matches is redundant
 resharper_redundant_always_match_subpattern_highlighting = none

 # 'true' is redundant as 'for'-statement condition
 resharper_for_statement_condition_is_true_highlighting = none

 # Type check for nullable type is equal to underlying type check
 resharper_redundant_nullable_type_mark_highlighting = none

 # Unsafe context declaration is redundant
 resharper_redundant_unsafe_context_highlighting = none

 # Unused nullable directive
 resharper_unused_nullable_directive_highlighting = none

 # Class with virtual (overridable) members never inherited (non-private accessibility)
 resharper_class_with_virtual_members_never_inherited_global_highlighting = none

 # Class with virtual (overridable) members never inherited (private accessibility)
 resharper_class_with_virtual_members_never_inherited_local_highlighting = none

 # Component of the tuple is never used
 resharper_unused_tuple_component_in_return_value_highlighting = none

 # 'DefaultParameterValueAttribute' must be used in conjunction with 'OptionalAttribute'
 resharper_meaningless_default_parameter_value_highlighting = none

 # Empty constructor
 resharper_empty_constructor_highlighting = none

 # Empty destructor
 resharper_empty_destructor_highlighting = none

 # Empty implementation of 'partial void' method is redundant
 resharper_redundant_partial_method_empty_implementation_highlighting = none

 # Empty namespace declaration
 resharper_empty_namespace_highlighting = none

 # Entity is only used to capture its name (non-private accessibility)
 resharper_entity_name_captured_only_global_highlighting = none

 # Entity is only used to capture its name (private accessibility)
 resharper_entity_name_captured_only_local_highlighting = none

 # Local function is never used
 resharper_unused_local_function_highlighting = none

 # Local function is never used
 resharper_unused_local_function_compiler_highlighting = none

 # Local function return value is never used
 resharper_unused_local_function_return_value_highlighting = none

 # Method return value is never used (non-private accessibility)
 resharper_unused_method_return_value_global_highlighting = none

 # Method return value is never used (private accessibility)
 resharper_unused_method_return_value_local_highlighting = none

 # Non-accessed local variable
 resharper_not_accessed_variable_highlighting = none

 # Non-accessed local variable is only used to discard the 'out' parameter value
 resharper_not_accessed_out_parameter_variable_highlighting = none

 # Not accessed primary constructor parameter
 resharper_not_accessed_primary_constructor_parameter_compiler_highlighting = none

 # Parameter is only used for precondition check (non-private accessibility)
 resharper_parameter_only_used_for_precondition_check_global_highlighting = none

 # Parameter is only used for precondition check (private accessibility)
 resharper_parameter_only_used_for_precondition_check_local_highlighting = none

 # Parameter output value is always discarded (non-private accessibility)
 resharper_out_parameter_value_is_always_discarded_global_highlighting = none

 # Parameter output value is always discarded (private accessibility)
 resharper_out_parameter_value_is_always_discarded_local_highlighting = none

 # 'params' modifier is always ignored on overrides
 resharper_redundant_params_highlighting = none

 # Redundant base constructor call
 resharper_redundant_base_constructor_call_highlighting = none

 # Redundant class or interface specification in base types list
 resharper_redundant_extends_list_entry_highlighting = none

 # Redundant member initializer
 resharper_redundant_default_member_initializer_highlighting = none

 # Redundant member override
 resharper_redundant_overridden_member_highlighting = none

 # Redundant method overload (non-private accessibility)
 resharper_redundant_overload_global_highlighting = none

 # Redundant method overload (private accessibility)
 resharper_redundant_overload_local_highlighting = none

 # Redundant 'partial' modifier on method declaration
 resharper_partial_method_with_single_part_highlighting = none

 # Redundant 'partial' modifier on type declaration
 resharper_partial_type_with_single_part_highlighting = none

 # Sealed member in sealed class
 resharper_sealed_member_in_sealed_class_highlighting = none

 # Type is never used (non-private accessibility)
 resharper_unused_type_global_highlighting = none

 # Type is never used (private accessibility)
 resharper_unused_type_local_highlighting = none

 # Type member is never accessed via base type (non-private accessibility)
 resharper_unused_member_in_super_global_highlighting = none

 # Type member is never accessed via base type (private accessibility)
 resharper_unused_member_in_super_local_highlighting = none

 # Type member is never used (non-private accessibility)
 resharper_unused_member_global_highlighting = none

 # Type member is never used (private accessibility)
 resharper_unused_member_local_highlighting = none

 # Type member is only used in overrides (non-private accessibility)
 resharper_unused_member_hierarchy_global_highlighting = none

 # Type member is only used in overrides (private accessibility)
 resharper_unused_member_hierarchy_local_highlighting = none

 # Underlying type of enum is 'int'
 resharper_enum_underlying_type_is_int_highlighting = none

 # Unused label
 resharper_unused_label_highlighting = none

 # Unused local variable
 resharper_unused_variable_highlighting = none

 # Unused parameter (non-private accessibility)
 resharper_unused_parameter_global_highlighting = none

 # Unused parameter (private accessibility)
 resharper_unused_parameter_local_highlighting = none

 # Unused parameter in partial method
 resharper_unused_parameter_in_partial_method_highlighting = none

 # Unused positional parameter
 resharper_unused_positional_parameter_compiler_highlighting = none

 # Unused type parameter
 resharper_unused_type_parameter_highlighting = none

 # Virtual (overridable) member is never overridden (non-private accessibility)
 resharper_virtual_member_never_overridden_global_highlighting = none

 # Virtual (overridable) member is never overridden (private accessibility)
 resharper_virtual_member_never_overridden_local_highlighting = none

 # Vulnerable API usage
 resharper_vulnerable_api_highlighting = none

 # Typo in comment
 resharper_comment_typo_highlighting = none

 # Typo in identifier
 resharper_identifier_typo_highlighting = none

 # Typo in string literal
 resharper_string_literal_typo_highlighting = none

 # Add parentheses to avoid non-obvious precedence
 resharper_arrange_missing_parentheses_highlighting = none

 # Add/remove qualifier for static members
 resharper_arrange_static_member_qualifier_highlighting = none

 # Add/remove 'this.' qualifier
 resharper_arrange_this_qualifier_highlighting = none

 # Adjust modifiers declaration order
 resharper_arrange_modifiers_order_highlighting = none

 # Arrange null checking pattern
 resharper_arrange_null_checking_pattern_highlighting = none

 # Join or separate attributes in section
 resharper_arrange_attributes_highlighting = none

 # Join or separate 'var' in deconstruction declarations
 resharper_arrange_var_keywords_in_deconstructing_declaration_highlighting = none

 # Place assignment expression into block
 resharper_place_assignment_expression_into_block_highlighting = none

 # Remove redundant parentheses
 resharper_arrange_redundant_parentheses_highlighting = none

 # Replace built-in type reference with a CLR type name or a keyword
 resharper_built_in_type_reference_style_highlighting = none

 # Replace built-in type reference with a CLR type name or a keyword in static member access expressions
 resharper_built_in_type_reference_style_for_member_access_highlighting = none

 # Separate control transfer statement with blank line
 resharper_separate_control_transfer_statement_highlighting = none

 # Unnecessary whitespace at the end of line
 resharper_unnecessary_whitespace_highlighting = none

 # Usage of tabulation character for indentation is prohibited
 resharper_tabs_are_disallowed_highlighting = none

 # Use explicit or implicit modifier definition for type members
 resharper_arrange_type_member_modifiers_highlighting = none

 # Use explicit or implicit modifier definition for types
 resharper_arrange_type_modifiers_highlighting = none

 # Use preferred argument style
 resharper_arguments_style_other_highlighting = none

 # Use preferred argument style for anonymous functions
 resharper_arguments_style_anonymous_function_highlighting = none

 # Use preferred argument style for literal values
 resharper_arguments_style_literal_highlighting = none

 # Use preferred argument style for named expressions
 resharper_arguments_style_named_expression_highlighting = none

 # Use preferred argument style for string literal values
 resharper_arguments_style_string_literal_highlighting = none

 # Use preferred body style (convert into constructor or destructor with preferred body style)
 resharper_arrange_constructor_or_destructor_body_highlighting = none

 # Use preferred body style (convert into local function with preferred body style)
 resharper_arrange_local_function_body_highlighting = none

 # Use preferred body style (convert into method or operator with preferred body style)
 resharper_arrange_method_or_operator_body_highlighting = none

 # Use preferred body style (convert into property, indexer, or event with preferred body style)
 resharper_arrange_accessor_owner_body_highlighting = none

 # Use preferred braces style (enforce braces in 'do-while' statement)
 resharper_enforce_do_while_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'fixed' statement)
 resharper_enforce_fixed_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'for' statement)
 resharper_enforce_for_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'foreach' statement)
 resharper_enforce_foreach_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'if' statement)
 resharper_enforce_if_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'lock' statement)
 resharper_enforce_lock_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'using' statement)
 resharper_enforce_using_statement_braces_highlighting = none

 # Use preferred braces style (enforce braces in 'while' statement)
 resharper_enforce_while_statement_braces_highlighting = none

 # Use preferred braces style (remove redundant braces)
 resharper_remove_redundant_braces_highlighting = none

 # Use preferred namespace body style
 resharper_arrange_namespace_body_highlighting = none

 # Use preferred style for discard declaration
 resharper_suggest_discard_declaration_var_style_highlighting = none

 # Use preferred style for trailing comma before new line in multiline lists
 resharper_arrange_trailing_comma_in_multiline_lists_highlighting = none

 # Use preferred style for trailing comma when the last element is not followed by a new line
 resharper_arrange_trailing_comma_in_singleline_lists_highlighting = none

 # Use preferred style of default value expression when type is evident
 resharper_arrange_default_value_when_type_evident_highlighting = none

 # Use preferred style of default value expression when type is not evident
 resharper_arrange_default_value_when_type_not_evident_highlighting = none

 # Use preferred style of 'new' expression when created type is evident
 resharper_arrange_object_creation_when_type_evident_highlighting = none

 # Use preferred style of 'new' expression when created type is not evident
 resharper_arrange_object_creation_when_type_not_evident_highlighting = none

 # Use preferred 'var' style (elsewhere)
 resharper_suggest_var_or_type_elsewhere_highlighting = none

 # Use preferred 'var' style (for built-in types)
 resharper_suggest_var_or_type_built_in_types_highlighting = none

 # Use preferred 'var' style (in deconstruction declarations)
 resharper_suggest_var_or_type_deconstruction_declarations_highlighting = none

 # Use preferred 'var' style (when type is simple)
 resharper_suggest_var_or_type_simple_types_highlighting = none

 # Alternative non-allocating method available
 resharper_unity_prefer_non_alloc_api_highlighting = none

 # Avoid 'base.OnGUI()' in classes derived from 'PropertyDrawer'
 resharper_unity_property_drawer_on_gui_base_highlighting = none

 # Cannot resolve component or scriptable object
 resharper_unity_unresolved_component_or_scriptable_object_highlighting = none

 # DOTS: IAspect fields are required to be one of the following types: RefRW, RefRO, EnabledRefRW, EnabledRefRO, DynamicBuffer, or Entity
 resharper_unity_entities_aspect_wrong_fields_type_highlighting = none

 # DOTS: Inconsistent type keywords
 resharper_unity_entities_inconsistent_modifiers_for_dots_inheritor_highlighting = none

 # DOTS: The type specified must be a structure type
 resharper_unity_entities_must_be_struct_for_dots_inheritor_highlighting = none

 # Event function with the same name is already declared
 resharper_unity_duplicate_event_function_highlighting = none

 # Expected a type derived from 'Component' or 'MonoBehaviour'
 resharper_unity_expected_component_highlighting = none

 # Expected a type derived from 'ScriptableObject'
 resharper_unity_expected_scriptable_object_highlighting = none

 # Field of 'ComponentLookup' type must be updated before being used.
 resharper_unity_entities_not_updated_component_lookup_highlighting = none

 # File name should match the name of the assembly
 resharper_mismatched_asmdef_filename_highlighting = none

 # Group path is not defined
 resharper_odin_odin_unknown_grouping_path_highlighting = none

 # Implicit check for Unity object lifetime
 resharper_unity_unity_object_null_comparison_highlighting = none

 # Incorrect method signature
 resharper_unity_incorrect_method_signature_highlighting = none

 # Incorrect Odin's group attribute type
 resharper_odin_odin_member_wrong_grouping_attribute_highlighting = none

 # Member appears in multiple UI groups simultaneously
 resharper_odin_odin_member_present_in_multiple_groups_highlighting = none

 # Method referenced in string literal does not have the expected signature
 resharper_unity_incorrect_method_signature_in_string_literal_highlighting = none

 # 'MonoBehaviour' instances must be instantiated with 'GameObject.AddComponent<T>()' instead of 'new'
 resharper_unity_incorrect_mono_behaviour_instantiation_highlighting = none

 # Parameter should be derived from 'Component'
 resharper_unity_parameter_not_derived_from_component_highlighting = none

 # Possible incorrect application of attribute to multiple fields
 resharper_unity_possible_misapplication_of_attribute_to_multiple_fields_highlighting = none

 # Possible unintended bypass of lifetime check of underlying Unity engine object (null coalescing on a type deriving from 'UnityEngine.Object' bypasses the lifetime check on the underlying Unity engine object)
 resharper_unity_no_null_coalescing_highlighting = none

 # Possible unintended bypass of lifetime check of underlying Unity engine object (null propagating on a type deriving from 'UnityEngine.Object' bypasses the lifetime check on the underlying Unity engine object)
 resharper_unity_no_null_propagation_highlighting = none

 # Possible unintended bypass of lifetime check of underlying Unity engine object (pattern matching null checks on a type deriving from 'UnityEngine.Object' bypasses the lifetime check on the underlying Unity engine object)
 resharper_unity_no_null_pattern_matching_highlighting = none

 # Prefer GUID-based assembly references
 resharper_unity_prefer_guid_reference_highlighting = none

 # Redundant attribute usage (attribute is redundant when applied to this declaration type)
 resharper_unity_redundant_attribute_on_target_highlighting = none

 # Redundant attribute usage (redundant 'FormerlySerializedAs' attribute)
 resharper_unity_redundant_formerly_serialized_as_attribute_highlighting = none

 # Redundant attribute usage (redundant 'HideInInspector' attribute)
 resharper_unity_redundant_hide_in_inspector_attribute_highlighting = none

 # Redundant attribute usage (redundant 'InitializeOnLoad' attribute)
 resharper_unity_redundant_initialize_on_load_attribute_highlighting = none

 # Redundant attribute usage (redundant 'SerializeField' attribute)
 resharper_unity_redundant_serialize_field_attribute_highlighting = none

 # Redundant Unity event function
 resharper_unity_redundant_event_function_highlighting = none

 # Repeated access of property on built in component is inefficient
 resharper_unity_inefficient_property_access_highlighting = none

 # Scene does not exist
 resharper_unity_load_scene_unexisting_scene_highlighting = none

 # Scene is disabled in the build settings
 resharper_unity_load_scene_disabled_scene_name_highlighting = none

 # 'ScriptableObject' instances must be instantiated with 'ScriptableObject.CreateInstance<T>()' instead of 'new'
 resharper_unity_incorrect_scriptable_object_instantiation_highlighting = none

 # Setting 'parent' property immediately after object instantiation is inefficient
 resharper_unity_instantiate_without_parent_highlighting = none

 # Short scene name is not unique
 resharper_unity_load_scene_ambiguous_scene_name_highlighting = none

 # String based graphics property lookup is inefficient
 resharper_unity_prefer_address_by_id_to_graphics_params_highlighting = none

 # String based lookup of component type is inefficient
 resharper_unity_prefer_generic_method_overload_highlighting = none

 # SystemApi.Query<...> type parameters must be Aspect, RefRO, or RefRW
 resharper_unity_entities_must_be_surrounded_with_ref_rw_ro_highlighting = none

 # The index is missing in the build settings
 resharper_unity_load_scene_wrong_index_highlighting = none

 # The input name is not defined in the Input manager
 resharper_unity_unknown_input_axes_highlighting = none

 # The layer is not defined in the 'Tags & Layers'
 resharper_unity_unknown_layer_highlighting = none

 # The resource is not defined in the project
 resharper_unity_unknown_resource_highlighting = none

 # The same shortcut is defined for another menu item
 resharper_unity_duplicate_shortcut_highlighting = none

 # The tag is not defined in the 'Tags & Layers'
 resharper_unity_unknown_tag_highlighting = none

 # There is no animator state with the same name in the project.
 resharper_unity_unknown_animator_state_name_highlighting = none

 # There is no scene with the same name in the build settings
 resharper_unity_load_scene_unknown_scene_name_highlighting = none

 # To use the result of a 'GetSingleton' call in the function, 'OnCreate' must include a 'RequireForUpdate' call
 resharper_unity_entities_singleton_must_be_requested_highlighting = none

 # Use 'CompareTag' instead of explicit string comparison
 resharper_unity_explicit_tag_comparison_highlighting = none

 # Accessing managed indexers is not supported
 resharper_unity_burst_accessing_managed_indexer_highlighting = none

 # Accessing managed methods is not supported
 resharper_unity_burst_accessing_managed_method_highlighting = none

 # Boxing is not supported
 resharper_unity_burst_boxing_not_supported_highlighting = none

 # Burst: String.Format(format, ...) invalid argument type
 resharper_unity_burst_string_format_invalid_argument_highlighting = none

 # Burst: The variable resolves to System.String, which may result in invalid managed method calls at the Burst-compiled call stack
 resharper_unity_burst_local_string_variable_declaration_highlighting = none

 # Creating a managed type is not supported
 resharper_unity_burst_creating_managed_type_highlighting = none

 # Debug logging functions only accept strings
 resharper_unity_burst_debug_log_invalid_argument_highlighting = none

 # Function signature cannot contain managed types
 resharper_unity_burst_function_signature_contains_managed_types_highlighting = none

 # Loading from a non-readonly static field is not supported
 resharper_unity_burst_loading_static_not_readonly_highlighting = none

 # Loading managed type is not supported
 resharper_unity_burst_loading_managed_type_highlighting = none

 # Shared static type parameter requires the unmanaged constraint
 resharper_unity_shared_static_unmanaged_type_highlighting = none

 # Some SharedStatic`1.GetOrCreate overloads cause compiler errors
 resharper_unity_burst_shared_static_create_highlighting = none

 # String.Format(format, ...) only accepts string literals and const strings
 resharper_unity_burst_string_format_invalid_format_highlighting = none

 # The 'foreach' construction is not supported
 resharper_unity_burst_foreach_not_supported_highlighting = none

 # Try statement is not supported
 resharper_unity_burst_try_not_supported_highlighting = none

 # Typeof is prohibited in Burst
 resharper_unity_burst_typeof_expression_highlighting = none

 # Writing to a static field is not supported
 resharper_unity_burst_write_static_field_highlighting = none

 # 'Camera.main' is expensive
 resharper_unity_performance_critical_code_camera_main_highlighting = none

 # Expensive method invocation
 resharper_unity_performance_critical_code_invocation_highlighting = none

 # Expensive null comparison
 resharper_unity_performance_critical_code_null_comparison_highlighting = none

 # Order of multiplication operations is inefficient
 resharper_unity_inefficient_multiplication_order_highlighting = none

 # Use jagged or one-dimensional array instead of multidimensional array
 resharper_unity_inefficient_multidimensional_array_usage_highlighting = none

 # Dependency for the plugin is missing in the project file
 resharper_c_sharp_missing_plugin_dependency_highlighting = none

 # Module with this name does not exist
 resharper_c_sharp_build_cs_invalid_module_name_highlighting = none

 # Console output in Xunit tests
 resharper_xunit_xunit_test_with_console_output_highlighting = none

 ## **END** ReSharper Inspect Code **END**
No results found