rubocop.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://www.rubyschema.org/rubocop.json",
  "title": "Rubocop Configuration",
  "definitions": {
    "cop": {
      "properties": {
        "Enabled": {
          "type": "boolean",
          "markdownDescription": "Enable or disable this cop. When set to `false`, the cop will not run. [Docs](https://docs.rubocop.org/rubocop/configuration.html#enabled)"
        },
        "Include": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string"
          },
          "markdownDescription": "File patterns (globs) to include for this cop. Files matching these patterns will be checked even if they would otherwise be excluded."
        },
        "Exclude": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string"
          },
          "markdownDescription": "File patterns (globs) to exclude from this cop. Files matching these patterns will not be checked."
        },
        "Severity": {
          "enum": [
            "info",
            "refactor",
            "convention",
            "warning",
            "error",
            "fatal"
          ],
          "markdownEnumDescriptions": [
            "Informational severity. Does not cause RuboCop to return a non-zero exit code.",
            "Refactoring suggestion. Indicates code that could be restructured.",
            "Convention violation. Indicates a violation of coding conventions.",
            "Warning level. Indicates a potential problem that should be reviewed.",
            "Error level. Indicates a problem that should be fixed.",
            "Fatal level. Indicates a critical issue that must be fixed."
          ],
          "markdownDescription": "Severity level for offenses detected by this cop. Cops with `info` severity will not cause RuboCop to return a non-zero exit code. [Docs](https://docs.rubocop.org/rubocop/configuration.html#severity)"
        },
        "Details": {
          "type": "string",
          "markdownDescription": "Additional details about this cop that will be shown when RuboCop is run with the `--extra-details` flag or when `ExtraDetails` is set to `true` in your global configuration. [Docs](https://docs.rubocop.org/rubocop/configuration.html#details)"
        },
        "AutoCorrect": {
          "markdownDescription": "Configure Rubocop’s autocorrection behavior. [Docs](https://docs.rubocop.org/rubocop/configuration.html#autocorrect)",
          "oneOf": [
            {
              "type": "boolean"
            },
            {
              "enum": ["always", "contextual", "disabled"],
              "markdownEnumDescriptions": [
                "Enables autocorrection",
                "Enables autocorrection when launched from the `rubocop` command but not via the LSP.",
                "Disables autocorrection"
              ]
            }
          ]
        },
        "StyleGuide": {
          "type": "string",
          "markdownDescription": "URL fragment (hash) pointing to the style guide entry for this cop. Combined with `StyleGuideBaseURL` to form the complete URL."
        },
        "VersionAdded": {
          "type": "string",
          "pattern": "^\\d+\\.\\d+$",
          "markdownDescription": "The RuboCop version in which this cop was added, in the format `major.minor`."
        },
        "VersionChanged": {
          "type": "string",
          "pattern": "^\\d+\\.\\d+$",
          "markdownDescription": "The latest RuboCop version in which this cop was changed in a user-impacting way (new config, updated defaults, etc), in the format `major.minor`."
        }
      }
    },
    "department": {
      "properties": {
        "Enabled": {
          "type": "boolean",
          "markdownDescription": "Enable or disable all cops in this department. Individual cops can still override this setting."
        },
        "StyleGuideBaseURL": {
          "type": "string",
          "format": "uri",
          "markdownDescription": "Base URL for the style guide. Combined with each cops `StyleGuide` value to form complete style guide URLs for this department. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-style-guide-url)"
        },
        "DocumentationBaseURL": {
          "type": "string",
          "format": "uri",
          "markdownDescription": "Base URL for the documentation. Used to generate documentation links for cops in this department. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-documentation-url)"
        },
        "DocumentationExtension": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "enum": [".md", "", ".txt"],
              "markdownEnumDescriptions": [
                "Markdown documentation files",
                "No file extension (bare files)",
                "Plain text documentation files"
              ]
            }
          ],
          "markdownDescription": "File extension for documentation files (e.g., `.md` for Markdown, `.html` for HTML). Defaults to `.html` if not specified."
        }
      }
    },
    "constant": {
      "type": "string",
      "pattern": "^(?:::)?[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*$"
    },
    "constants": {
      "type": "array",
      "uniqueItems": true,
      "items": {
        "$ref": "#/definitions/constant"
      }
    },
    "hashAlignmentEnforcedColonStyleEnum": {
      "enum": ["key", "separator", "table"],
      "markdownEnumDescriptions": [
        "Align hash values with the first key",
        "Align hash values with the colon separator",
        "Align hash values in table format"
      ]
    },
    "hashAlignmentEnforcedHashRocketStyleEnum": {
      "enum": ["key", "separator", "table"],
      "markdownEnumDescriptions": [
        "Align hash values with the first key",
        "Align hash values with the hash rocket (=>)",
        "Align hash values in table format"
      ]
    }
  },
  "properties": {
    "inherit_gem": {
      "type": "object",
      "additionalProperties": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "uniqueItems": true
          }
        ]
      },
      "markdownDescription": "Inherit configuration from one or more gems. Allows you to share RuboCop configuration across multiple projects. The key is the gem name and the value is the relative path to the config file within the gem. [Docs](https://docs.rubocop.org/rubocop/configuration.html#inheriting-configuration-from-a-dependency-gem)"
    },
    "inherit_from": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string"
          }
        }
      ],
      "markdownDescription": "Inherit configuration from one or more files. Can be local file paths or remote URLs. Files can be given with absolute paths or paths relative to the file where they are referenced. Also accepts glob patterns. [Docs](https://docs.rubocop.org/rubocop/configuration.html#inheriting-from-another-configuration-file-in-the-project)"
    },
    "inherit_mode": {
      "type": "object",
      "properties": {
        "merge": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "enum": ["Exclude", "Include"],
            "markdownEnumDescriptions": [
              "Merge `Exclude` arrays from inherited configs instead of overriding",
              "Merge `Include` arrays from inherited configs instead of overriding"
            ]
          },
          "markdownDescription": "Array configuration keys that should be merged with inherited values rather than overriding them"
        }
      },
      "markdownDescription": "Specifies which configuration keys with array values should be merged together instead of overriding the inherited value. This applies to both explicit inheritance via `inherit_from` and implicit inheritance from the default config. [Docs](https://docs.rubocop.org/rubocop/configuration.html#merging-arrays-using-inherit_mode)"
    },
    "AllCops": {
      "type": "object",
      "properties": {
        "Exclude": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string"
          },
          "markdownDescription": "File patterns (globs) to exclude from all cops. Files matching these patterns will not be inspected. To apply exclusions when specific files are passed as arguments, use `--force-exclusion`. [Docs](https://docs.rubocop.org/rubocop/configuration.html#includingexcluding-files)"
        },
        "Include": {
          "type": "array",
          "uniqueItems": true,
          "items": {
            "type": "string"
          },
          "markdownDescription": "File patterns (globs) to include for all cops. Files matching these patterns will be inspected. Overrides the default patterns from RuboCop. [Docs](https://docs.rubocop.org/rubocop/configuration.html#includingexcluding-files)"
        },
        "DisabledByDefault": {
          "type": "boolean",
          "markdownDescription": "When `true`, all cops except `Lint/Syntax` are disabled by default. Only cops explicitly enabled in configuration files will run. Cannot be used with `EnabledByDefault`. [Docs](https://docs.rubocop.org/rubocop/configuration.html#enabled)"
        },
        "EnabledByDefault": {
          "type": "boolean",
          "markdownDescription": "When `true`, all cops are enabled by default, including those that are normally disabled. Cannot be used with `DisabledByDefault`. [Docs](https://docs.rubocop.org/rubocop/configuration.html#enabled)"
        },
        "TargetRubyVersion": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "enum": [2.7, 3.0, 3.1, 3.2, 3.3, 3.4],
              "markdownEnumDescriptions": [
                "Ruby 2.7",
                "Ruby 3.0",
                "Ruby 3.1",
                "Ruby 3.2",
                "Ruby 3.3",
                "Ruby 3.4"
              ]
            }
          ],
          "markdownDescription": "The minimum Ruby version your code must support. Cops that detect version-specific features will adjust their behavior accordingly. If not specified, RuboCop will try to detect it from `.ruby-version`, `Gemfile.lock`, `*.gemspec`, or `.tool-versions`. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-target-ruby-version)"
        },
        "ParserEngine": {
          "enum": ["parser_whitequark", "parser_prism"],
          "markdownEnumDescriptions": [
            "Whitequark parser. Supports Ruby 2.0-3.4.",
            "Prism parser. Supports Ruby 3.3+ and is typically faster."
          ],
          "markdownDescription": "The parser backend to use. `parser_whitequark` supports Ruby 2.0-3.4, while `parser_prism` supports Ruby 3.3+ and is typically faster. Since RuboCop 1.75, the parser is chosen automatically if not specified. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-parser-engine)"
        },
        "StyleGuideBaseURL": {
          "type": "string",
          "format": "uri",
          "markdownDescription": "Base URL for the style guide. This is combined with individual cop `StyleGuide` values to generate complete URLs. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-style-guide-url)"
        },
        "DocumentationBaseURL": {
          "type": "string",
          "format": "uri",
          "markdownDescription": "Base URL for the documentation. Used to generate documentation links for all cops. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-documentation-url)"
        },
        "DocumentationExtension": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "enum": [".md", "", ".txt"],
              "markdownEnumDescriptions": [
                "Markdown documentation files",
                "No file extension (bare files)",
                "Plain text documentation files"
              ]
            }
          ],
          "markdownDescription": "File extension for documentation files (e.g., `.md` for Markdown). Defaults to `.html` if not specified. [Docs](https://docs.rubocop.org/rubocop/configuration.html#setting-the-documentation-url)"
        },
        "ActiveSupportExtensionsEnabled": {
          "type": "boolean",
          "markdownDescription": "When `true`, enables checking of Active Support extensions in relevant cops (e.g., `Style/HashExcept`). This allows RuboCop to recognize Rails/ActiveSupport-specific methods. [Docs](https://docs.rubocop.org/rubocop/configuration.html#enable-checking-active-support-extensions)"
        },
        "StringLiteralsFrozenByDefault": {
          "markdownDescription": "Set this to `true` if you enable frozen string literals globally with the `RUBYOPT` environment variable (e.g., `RUBYOPT=--enable=frozen-string-literal`). This affects how RuboCop analyzes string literals. [Docs](https://docs.rubocop.org/rubocop/configuration.html#opting-into-globally-frozen-string-literals)",
          "type": "boolean"
        },
        "MaxFilesInCache": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0
            },
            {
              "const": false
            }
          ],
          "markdownDescription": "Maximum number of files RuboCop stores in its result cache before pruning. Set to `false` to disable cache pruning entirely. [Docs](https://docs.rubocop.org/rubocop/usage/caching.html)"
        }
      },
      "not": {
        "allOf": [
          {
            "required": ["DisabledByDefault"]
          },
          {
            "required": ["EnabledByDefault"]
          }
        ]
      },
      "markdownDescription": "Global configuration that applies to all cops. These settings affect RuboCops overall behavior. [Docs](https://docs.rubocop.org/rubocop/configuration.html)"
    },
    "Bundler": {
      "$ref": "#/definitions/department"
    },
    "Gemspec": {
      "$ref": "#/definitions/department"
    },
    "Layout": {
      "$ref": "#/definitions/department"
    },
    "Lint": {
      "$ref": "#/definitions/department"
    },
    "Metrics": {
      "$ref": "#/definitions/department"
    },
    "Migration": {
      "$ref": "#/definitions/department"
    },
    "Naming": {
      "$ref": "#/definitions/department"
    },
    "Security": {
      "$ref": "#/definitions/department"
    },
    "Style": {
      "$ref": "#/definitions/department"
    },
    "Bundler/DuplicatedGem": {
      "markdownDescription": "Detects duplicate gem declarations in Gemfile. Helps keep dependencies organized. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlerduplicatedgem)",
      "$ref": "#/definitions/cop"
    },
    "Bundler/DuplicatedGroup": {
      "markdownDescription": "Detects duplicate group declarations in Gemfile. Promotes cleaner Gemfile structure. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlerduplicatedgroup)",
      "$ref": "#/definitions/cop"
    },
    "Bundler/GemComment": {
      "markdownDescription": "Enforces comments above gem declarations for documentation. Improves gem intent clarity. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlergemcomment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "OnlyFor": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "enum": [
                      "version_specifiers",
                      "restrictive_version_specifiers",
                      "bitbucket",
                      "gist",
                      "git",
                      "github",
                      "source"
                    ],
                    "markdownEnumDescriptions": [
                      "Require comments for gems with version specifiers",
                      "Require comments for gems with restrictive version specifiers (e.g., exact versions)",
                      "Require comments for gems sourced from Bitbucket",
                      "Require comments for gems sourced from GitHub Gist",
                      "Require comments for gems sourced from git repositories",
                      "Require comments for gems sourced from GitHub",
                      "Require comments for gems with custom source specifications"
                    ]
                  }
                ]
              }
            }
          }
        }
      ]
    },
    "Bundler/GemFilename": {
      "markdownDescription": "Enforces naming convention for Gemfile. Keeps project structure consistent. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlergemfilename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["Gemfile", "gems.rb"],
              "markdownEnumDescriptions": [
                "Use `Gemfile` as the filename",
                "Use `gems.rb` as the filename"
              ]
            }
          }
        }
      ]
    },
    "Bundler/GemVersion": {
      "markdownDescription": "Enforces use of version specifiers in gem declarations. Improves dependency management. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlergemversion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["required", "forbidden"],
              "markdownEnumDescriptions": [
                "Require version specifiers for all gems",
                "Forbid version specifiers for all gems"
              ]
            },
            "AllowedGems": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Bundler/InsecureProtocolSource": {
      "markdownDescription": "Warns against insecure gem sources (http instead of https). Improves security. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlerinsecureprotocolsource)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowHttpProtocol": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Bundler/OrderedGems": {
      "markdownDescription": "Enforces alphabetical ordering of gems in groups. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_bundler#bundlerorderedgems)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "TreatCommentsAsGroupSeparators": {
              "type": "boolean"
            },
            "ConsiderPunctuation": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Gemspec/AddRuntimeDependency": {
      "markdownDescription": "Detects add_runtime_dependency in gemspec files. Suggests using gem dependencies. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecaddruntimedependency)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/AttributeAssignment": {
      "markdownDescription": "Detects attribute assignments that should use methods. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec.html#gemspecattributeassignment)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/DependencyVersion": {
      "markdownDescription": "Enforces explicit version specifications in gem dependencies. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecdependencyversion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["required", "forbidden"],
              "markdownEnumDescriptions": [
                "Require version specifications for dependencies",
                "Forbid version specifications for dependencies"
              ]
            }
          }
        }
      ]
    },
    "Gemspec/DeprecatedAttributeAssignment": {
      "markdownDescription": "Detects deprecated gemspec attribute assignment patterns. Encourages modern syntax. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecdeprecatedattributeassignment)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/DevelopmentDependencies": {
      "markdownDescription": "Enforces that development dependencies are in development group. Improves gem organization. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecdevelopmentdependencies)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["Gemfile", "gems.rb", "gemspec"],
              "markdownEnumDescriptions": [
                "Place development dependencies in `Gemfile`",
                "Place development dependencies in `gems.rb`",
                "Place development dependencies in gemspec file"
              ]
            }
          }
        }
      ]
    },
    "Gemspec/DuplicatedAssignment": {
      "markdownDescription": "Detects duplicate attribute assignments in gemspec. Helps keep gemspec clean. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecduplicatedassignment)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/OrderedDependencies": {
      "markdownDescription": "Enforces alphabetical ordering of dependencies in gemspec. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecordereddependencies)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "TreatCommentsAsGroupSeparators": {
              "type": "boolean"
            },
            "ConsiderPunctuation": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Gemspec/RequireMFA": {
      "markdownDescription": "Recommends enabling MFA for gem publishing. Improves security. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecrequiremfa)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/RequiredRubyVersion": {
      "markdownDescription": "Enforces explicitly specifying required Ruby version. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecrequiredrubyversion)",
      "$ref": "#/definitions/cop"
    },
    "Gemspec/RubyVersionGlobalsUsage": {
      "markdownDescription": "Discourages using Ruby version globals in gemspec. Use version methods instead. [Docs](https://docs.rubocop.org/rubocop/cops_gemspec#gemspecrubyversionglobalsusage)",
      "$ref": "#/definitions/cop"
    },
    "Layout/AccessModifierIndentation": {
      "markdownDescription": "Checks the indentation of `private`, `protected`, and `public` access modifiers. You can choose to indent them to the same level as the class/module definition or one level deeper. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutaccessmodifierindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["indent", "outdent"],
              "markdownEnumDescriptions": [
                "Indent access modifiers one level deeper than the class/module definition",
                "Align access modifiers with the class/module definition (no indentation)"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/ArgumentAlignment": {
      "markdownDescription": "Enforces consistent indentation for method arguments. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutargumentalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["with_first_argument", "with_fixed_indentation"],
              "markdownEnumDescriptions": [
                "Align subsequent arguments with the first argument",
                "Use fixed indentation for all arguments"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/ArrayAlignment": {
      "markdownDescription": "Enforces consistent alignment of array elements. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutarrayalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["with_first_element", "with_fixed_indentation"],
              "markdownEnumDescriptions": [
                "Align subsequent elements with the first element",
                "Use fixed indentation for all elements"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/AssignmentIndentation": {
      "markdownDescription": "Enforces consistent indentation for assignment statements. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutassignmentindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/BeginEndAlignment": {
      "markdownDescription": "Enforces alignment of begin/end blocks. Improves code readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutbeginendalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleAlignWith": {
              "enum": ["start_of_line", "begin"],
              "markdownEnumDescriptions": [
                "Align `end` with the start of the line containing `begin`",
                "Align `end` with the `begin` keyword"
              ]
            }
          }
        }
      ]
    },
    "Layout/BlockAlignment": {
      "markdownDescription": "Enforces alignment of block elements. Improves code structure. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutblockalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleAlignWith": {
              "enum": ["either", "start_of_block", "start_of_line"],
              "markdownEnumDescriptions": [
                "Allow either alignment style",
                "Align block `end` with the start of the block expression",
                "Align block `end` with the start of the line"
              ]
            }
          }
        }
      ]
    },
    "Layout/BlockEndNewline": {
      "markdownDescription": "Enforces placing closing brace on new line for multi-line blocks. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutblockendnewline)",
      "$ref": "#/definitions/cop"
    },
    "Layout/CaseIndentation": {
      "markdownDescription": "Enforces consistent indentation in case statements. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutcaseindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["case", "end"],
              "markdownEnumDescriptions": [
                "Indent `when` clauses one level relative to `case`",
                "Indent `when` clauses one level relative to `end`"
              ]
            },
            "IndentOneStep": {
              "type": "boolean"
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/ClassStructure": {
      "markdownDescription": "Enforces consistent ordering of class methods and attributes. Improves code organization. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutclassstructure)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ExpectedOrder": {
              "uniqueItems": true,
              "type": "array",
              "items": {
                "enum": [
                  "module_inclusion",
                  "constants",
                  "association",
                  "public_attribute_macros",
                  "public_delegate",
                  "macros",
                  "public_class_methods",
                  "initializer",
                  "public_methods",
                  "protected_attribute_macros",
                  "protected_methods",
                  "private_attribute_macros",
                  "private_delegate",
                  "private_methods"
                ],
                "markdownEnumDescriptions": [
                  "Module inclusion (`include`, `prepend`, `extend`)",
                  "Constant definitions",
                  "ActiveRecord associations",
                  "Public attribute macros (`attr_accessor`, etc.)",
                  "Public delegate definitions",
                  "General macros (validations, etc.)",
                  "Public class methods",
                  "`initialize` method",
                  "Public instance methods",
                  "Protected attribute macros",
                  "Protected instance methods",
                  "Private attribute macros",
                  "Private delegate definitions",
                  "Private instance methods"
                ]
              }
            },
            "Categories": {
              "type": "object",
              "properties": {
                "association": {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "enum": [
                          "belongs_to",
                          "has_one",
                          "has_many",
                          "has_and_belongs_to_many"
                        ],
                        "markdownEnumDescriptions": [
                          "ActiveRecord `belongs_to` associations",
                          "ActiveRecord `has_one` associations",
                          "ActiveRecord `has_many` associations",
                          "ActiveRecord `has_and_belongs_to_many` associations"
                        ]
                      }
                    ]
                  }
                },
                "attribute_macros": {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "enum": ["attr_accessor", "attr_reader", "attr_writer"],
                        "markdownEnumDescriptions": [
                          "Attribute accessor macros (both getter and setter)",
                          "Attribute reader macros (getter only)",
                          "Attribute writer macros (setter only)"
                        ]
                      }
                    ]
                  }
                },
                "macros": {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "enum": ["validates", "validate"],
                        "markdownEnumDescriptions": [
                          "ActiveModel `validates` declarations",
                          "ActiveModel custom `validate` declarations"
                        ]
                      }
                    ]
                  }
                },
                "module_inclusion": {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "enum": ["include", "prepend", "extend"],
                        "markdownEnumDescriptions": [
                          "Module `include` statements",
                          "Module `prepend` statements",
                          "Module `extend` statements"
                        ]
                      }
                    ]
                  }
                }
              }
            }
          }
        }
      ]
    },
    "Layout/ClosingHeredocIndentation": {
      "markdownDescription": "Enforces indentation of heredoc closing delimiter. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutclosingheredocindentation)",
      "$ref": "#/definitions/cop"
    },
    "Layout/ClosingParenthesisIndentation": {
      "markdownDescription": "Enforces indentation of closing parenthesis. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutclosingparenthesisindentation)",
      "$ref": "#/definitions/cop"
    },
    "Layout/CommentIndentation": {
      "markdownDescription": "Enforces consistent indentation of comments. Improves code readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutcommentindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowForAlignment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/ConditionPosition": {
      "markdownDescription": "Enforces consistent position of condition in if/unless statements. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutconditionposition)",
      "$ref": "#/definitions/cop"
    },
    "Layout/DefEndAlignment": {
      "markdownDescription": "Enforces alignment of def/end blocks. Improves code structure. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutdefendalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleAlignWith": {
              "enum": ["start_of_line", "def"],
              "markdownEnumDescriptions": [
                "Align `end` with the start of the line containing `def`",
                "Align `end` with the `def` keyword"
              ]
            }
          }
        }
      ]
    },
    "Layout/DotPosition": {
      "markdownDescription": "Enforces consistent position of dot in method chains. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutdotposition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["leading", "trailing"],
              "markdownEnumDescriptions": [
                "Place dots at the beginning of continuation lines",
                "Place dots at the end of lines being continued"
              ]
            }
          }
        }
      ]
    },
    "Layout/ElseAlignment": {
      "markdownDescription": "Enforces alignment of else keyword with if. Improves code readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutelsealignment)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyComment": {
      "markdownDescription": "Detects empty comments. Suggests removing unused comments. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptycomment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowBorderComment": {
              "type": "boolean"
            },
            "AllowMarginComment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/EmptyLineAfterGuardClause": {
      "markdownDescription": "Enforces blank line after guard clauses. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylineafterguardclause)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLineAfterMagicComment": {
      "markdownDescription": "Enforces blank line after magic comments. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylineaftermagiccomment)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAfterModuleInclusion": {
      "markdownDescription": "Enforces blank lines after module inclusions. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaftermoduleinclusion)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLineAfterMultilineCondition": {
      "markdownDescription": "Enforces blank line after multi-line conditions. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylineaftermultilinecondition)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLineBetweenDefs": {
      "markdownDescription": "Enforces blank line between method definitions. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinebetweendefs)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EmptyLineBetweenMethodDefs": {
              "type": "boolean"
            },
            "EmptyLineBetweenClassDefs": {
              "type": "boolean"
            },
            "EmptyLineBetweenModuleDefs": {
              "type": "boolean"
            },
            "DefLikeMacros": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "uniqueItems": true
            },
            "AllowAdjacentOneLineDefs": {
              "type": "boolean"
            },
            "NumberOfEmptyLines": {
              "type": "integer"
            }
          }
        }
      ]
    },
    "Layout/EmptyLines": {
      "markdownDescription": "Enforces consistent number of blank lines. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylines)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAroundAccessModifier": {
      "markdownDescription": "Enforces blank lines around access modifiers. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundaccessmodifier)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["around", "only_before"],
              "markdownEnumDescriptions": [
                "Require blank lines both before and after access modifiers",
                "Require blank lines only before access modifiers"
              ]
            }
          }
        }
      ]
    },
    "Layout/EmptyLinesAroundArguments": {
      "markdownDescription": "Enforces blank lines around method arguments. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundarguments)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAroundAttributeAccessor": {
      "markdownDescription": "Enforces blank lines around attribute accessors. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundattributeaccessor)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowAliasSyntax": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Layout/EmptyLinesAroundBeginBody": {
      "markdownDescription": "Enforces blank lines around begin/rescue/ensure bodies. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundbeginbody)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAroundBlockBody": {
      "markdownDescription": "Enforces blank lines around block bodies. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundblockbody)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["empty_lines", "no_empty_lines"],
              "markdownEnumDescriptions": [
                "Require empty lines inside block bodies",
                "Forbid empty lines inside block bodies"
              ]
            }
          }
        }
      ]
    },
    "Layout/EmptyLinesAroundClassBody": {
      "markdownDescription": "Enforces blank lines around class body. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundclassbody)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "empty_lines",
                "empty_lines_except_namespace",
                "empty_lines_special",
                "no_empty_lines",
                "beginning_only",
                "ending_only"
              ],
              "markdownEnumDescriptions": [
                "Require empty lines at the beginning and end of class bodies",
                "Require empty lines except for namespace classes",
                "Require empty lines with special handling for certain constructs",
                "Forbid empty lines at the beginning and end of class bodies",
                "Require empty lines only at the beginning of class bodies",
                "Require empty lines only at the end of class bodies"
              ]
            }
          }
        }
      ]
    },
    "Layout/EmptyLinesAroundExceptionHandlingKeywords": {
      "markdownDescription": "Enforces blank lines around exception handling keywords. Improves spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundexceptionhandlingkeywords)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAroundMethodBody": {
      "markdownDescription": "Enforces blank lines around method body. Improves code spacing. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundmethodbody)",
      "$ref": "#/definitions/cop"
    },
    "Layout/EmptyLinesAroundModuleBody": {
      "markdownDescription": "Enforces blank lines around module body. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutemptylinesaroundmodulebody)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "empty_lines",
                "empty_lines_except_namespace",
                "empty_lines_special",
                "no_empty_lines"
              ],
              "markdownEnumDescriptions": [
                "Require empty lines at the beginning and end of module bodies",
                "Require empty lines except for namespace modules",
                "Require empty lines with special handling for certain constructs",
                "Forbid empty lines at the beginning and end of module bodies"
              ]
            }
          }
        }
      ]
    },
    "Layout/EndAlignment": {
      "markdownDescription": "Enforces consistent alignment of end keyword. Improves code structure. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutendalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleAlignWith": {
              "enum": ["keyword", "variable", "start_of_line"],
              "markdownEnumDescriptions": [
                "Align `end` with the opening keyword (if, while, etc.)",
                "Align `end` with the variable in variable assignments",
                "Align `end` with the start of the line"
              ]
            }
          }
        }
      ]
    },
    "Layout/EndOfLine": {
      "markdownDescription": "Checks for consistent line endings (LF, CRLF, or platform-native). Inconsistent line endings can cause problems with version control systems and cross-platform development. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutendofline)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["native", "lf", "crlf"],
              "markdownEnumDescriptions": [
                "Use platform-native line endings (LF on Unix, CRLF on Windows)",
                "Use Unix-style line endings (LF)",
                "Use Windows-style line endings (CRLF)"
              ]
            }
          }
        }
      ]
    },
    "Layout/ExtraSpacing": {
      "markdownDescription": "Detects unnecessary extra spacing. Removes visual clutter. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutextraspacing)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowForAlignment": {
              "type": "boolean"
            },
            "AllowBeforeTrailingComments": {
              "type": "boolean"
            },
            "ForceEqualSignAlignment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/FirstArgumentIndentation": {
      "markdownDescription": "Enforces indentation of first method argument. Improves code alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstargumentindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "consistent",
                "consistent_relative_to_receiver",
                "special_for_inner_method_call",
                "special_for_inner_method_call_in_parentheses"
              ],
              "markdownEnumDescriptions": [
                "Use consistent indentation for all arguments",
                "Use consistent indentation relative to the receiver",
                "Special handling for inner method calls",
                "Special handling for inner method calls in parentheses"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/FirstArrayElementIndentation": {
      "markdownDescription": "Enforces indentation of first array element. Improves code alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstarrayelementindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "special_inside_parentheses",
                "consistent",
                "align_brackets"
              ],
              "markdownEnumDescriptions": [
                "Special indentation rules inside parentheses",
                "Consistent indentation for all elements",
                "Align elements with the opening bracket"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/FirstArrayElementLineBreak": {
      "markdownDescription": "Enforces line break before first array element. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstarrayelementlinebreak)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowImplicitArrayLiterals": {
              "type": "boolean"
            },
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/FirstHashElementIndentation": {
      "markdownDescription": "Enforces indentation of first hash element. Improves code alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirsthashelementindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "special_inside_parentheses",
                "consistent",
                "align_braces"
              ],
              "markdownEnumDescriptions": [
                "Special indentation rules inside parentheses",
                "Consistent indentation for all elements",
                "Align elements with the opening brace"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/FirstHashElementLineBreak": {
      "markdownDescription": "Enforces line break before first hash element. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirsthashelementlinebreak)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/FirstMethodArgumentLineBreak": {
      "markdownDescription": "Enforces line break before first method argument. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstmethodargumentlinebreak)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Layout/FirstMethodParameterLineBreak": {
      "markdownDescription": "Enforces line break before first method parameter. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstmethodparameterlinebreak)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/FirstParameterIndentation": {
      "markdownDescription": "Enforces indentation of first parameter. Improves code alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutfirstparameterindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["consistent", "align_parentheses"],
              "markdownEnumDescriptions": [
                "Use consistent indentation for all parameters",
                "Align parameters with the opening parenthesis"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/HashAlignment": {
      "markdownDescription": "Enforces consistent alignment of hash elements. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layouthashalignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedHashRocketStyle": {
              "anyOf": [
                {
                  "$ref": "#/definitions/hashAlignmentEnforcedHashRocketStyleEnum"
                },
                {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "$ref": "#/definitions/hashAlignmentEnforcedHashRocketStyleEnum"
                  }
                }
              ]
            },
            "EnforcedColonStyle": {
              "anyOf": [
                {
                  "$ref": "#/definitions/hashAlignmentEnforcedColonStyleEnum"
                },
                {
                  "type": "array",
                  "uniqueItems": true,
                  "items": {
                    "$ref": "#/definitions/hashAlignmentEnforcedColonStyleEnum"
                  }
                }
              ]
            },
            "EnforcedLastArgumentHashStyle": {
              "enum": [
                "always_inspect",
                "always_ignore",
                "ignore_implicit",
                "ignore_explicit"
              ],
              "markdownEnumDescriptions": [
                "Always inspect hash alignment in last argument",
                "Always ignore hash alignment in last argument",
                "Ignore hash alignment for implicit hashes in last argument",
                "Ignore hash alignment for explicit hashes in last argument"
              ]
            }
          }
        }
      ]
    },
    "Layout/HeredocArgumentClosingParenthesis": {
      "markdownDescription": "Enforces placement of closing paren with heredoc args. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutheredocargumentclosingparenthesis)",
      "$ref": "#/definitions/cop"
    },
    "Layout/HeredocIndentation": {
      "markdownDescription": "Enforces consistent heredoc indentation. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutheredocindentation)",
      "$ref": "#/definitions/cop"
    },
    "Layout/IndentationConsistency": {
      "markdownDescription": "Enforces consistent indentation style. Improves code readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutindentationconsistency)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["normal", "indented_internal_methods"]
            }
          }
        }
      ]
    },
    "Layout/IndentationStyle": {
      "markdownDescription": "Enforces consistent use of either spaces or tabs for indentation. Mixing spaces and tabs can lead to display issues in different editors. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutindentationstyle)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["spaces", "tabs"]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/IndentationWidth": {
      "markdownDescription": "Checks that indentation uses the configured number of spaces. The default is 2 spaces per indentation level, which is the Ruby community standard. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutindentationwidth)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Width": {
              "type": "integer"
            },
            "EnforcedStyleAlignWith": {
              "enum": ["start_of_line", "relative_to_receiver"]
            },
            "AllowedPatterns": {
              "type": "array",
              "markdownDescription": "Allowed regular expression patterns.",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Layout/InitialIndentation": {
      "markdownDescription": "Enforces proper indentation at file start. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutinitialindentation)",
      "$ref": "#/definitions/cop"
    },
    "Layout/LeadingCommentSpace": {
      "markdownDescription": "Enforces space after comment hash. Improves comment readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutleadingcommentspace)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowDoxygenCommentStyle": {
              "type": "boolean"
            },
            "AllowGemfileRubyComment": {
              "type": "boolean"
            },
            "AllowRBSInlineAnnotation": {
              "type": "boolean"
            },
            "AllowSteepAnnotation": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/LeadingEmptyLines": {
      "markdownDescription": "Enforces no leading empty lines in file. Improves file formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutleadingemptylines)",
      "$ref": "#/definitions/cop"
    },
    "Layout/LineContinuationLeadingSpace": {
      "markdownDescription": "Enforces leading space for line continuations. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutlinecontinuationleadingspace)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["leading", "trailing"],
              "markdownEnumDescriptions": [
                "Place whitespace before the backslash in line continuations",
                "Place whitespace after the backslash in line continuations"
              ]
            }
          }
        }
      ]
    },
    "Layout/LineContinuationSpacing": {
      "markdownDescription": "Enforces spacing around line continuation characters. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutlinecontinuationspacing)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require a space after the backslash in line continuations",
                "Disallow spaces after the backslash in line continuations"
              ]
            }
          }
        }
      ]
    },
    "Layout/LineEndStringConcatenationIndentation": {
      "markdownDescription": "Enforces indentation for string concatenation at line end. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutlineendstringconcatenationindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["aligned", "indented"],
              "markdownEnumDescriptions": [
                "Align continued string parts with the first part",
                "Indent continued string parts relative to the first part"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/LineLength": {
      "markdownDescription": "Enforces a maximum line length. Long lines can be hard to read and may indicate code that should be refactored. The default maximum is typically 120 characters. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutlinelength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Max": {
              "type": "integer"
            },
            "AllowHeredoc": {
              "type": "boolean"
            },
            "AllowURI": {
              "type": "boolean"
            },
            "AllowQualifiedName": {
              "type": "boolean"
            },
            "URISchemes": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowRBSInlineAnnotation": {
              "type": "boolean"
            },
            "IgnoreCopDirectives": {
              "type": "boolean"
            },
            "AllowCopDirectives": {
              "type": "boolean"
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "SplitStrings": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/MultilineArrayBraceLayout": {
      "markdownDescription": "Enforces consistent bracket placement for multi-line arrays. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinearraybracelayout)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["symmetrical", "new_line", "same_line"],
              "markdownEnumDescriptions": [
                "Opening and closing brackets must be on the same relative position (both on own lines or both on same line as content)",
                "Closing bracket must be on its own line",
                "Closing bracket must be on the same line as the last element"
              ]
            }
          }
        }
      ]
    },
    "Layout/MultilineArrayLineBreaks": {
      "markdownDescription": "Enforces line breaks in multi-line arrays. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinearraylinebreaks)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/MultilineAssignmentLayout": {
      "markdownDescription": "Enforces consistent formatting for multi-line assignments. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilineassignmentlayout)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["same_line", "new_line"],
              "markdownEnumDescriptions": [
                "Allow the right-hand side to start on the same line as the assignment operator",
                "Require the right-hand side to start on a new line after the assignment operator"
              ]
            }
          }
        }
      ]
    },
    "Layout/MultilineBlockLayout": {
      "markdownDescription": "Enforces proper layout for multi-line blocks. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilineblocklayout)",
      "$ref": "#/definitions/cop"
    },
    "Layout/MultilineHashBraceLayout": {
      "markdownDescription": "Enforces consistent bracket placement for multi-line hashes. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinehashbracelayout)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["symmetrical", "new_line", "same_line"],
              "markdownEnumDescriptions": [
                "Opening and closing braces must be on the same relative position (both on own lines or both on same line as content)",
                "Closing brace must be on its own line",
                "Closing brace must be on the same line as the last element"
              ]
            }
          }
        }
      ]
    },
    "Layout/MultilineHashKeyLineBreaks": {
      "markdownDescription": "Enforces line breaks for multi-line hash keys. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinehashkeylinebreaks)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/MultilineMethodArgumentLineBreaks": {
      "markdownDescription": "Enforces line breaks in multi-line method arguments. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinemethodargumentlinebreaks)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/MultilineMethodCallBraceLayout": {
      "markdownDescription": "Enforces consistent bracket placement for method calls. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinemethodcallbracelayout)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["symmetrical", "new_line", "same_line"],
              "markdownEnumDescriptions": [
                "Opening and closing parentheses must be on the same relative position (both on own lines or both on same line as content)",
                "Closing parenthesis must be on its own line",
                "Closing parenthesis must be on the same line as the last argument"
              ]
            }
          }
        }
      ]
    },
    "Layout/MultilineMethodCallIndentation": {
      "markdownDescription": "Enforces consistent indentation for method calls. Improves alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinemethodcallindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["aligned", "indented", "indented_relative_to_receiver"],
              "markdownEnumDescriptions": [
                "Align method arguments with the first argument",
                "Indent method arguments with a fixed indentation",
                "Indent method arguments relative to the receiver object"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/MultilineMethodDefinitionBraceLayout": {
      "markdownDescription": "Enforces bracket placement in method definitions. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinemethoddefinitionbracelayout)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["symmetrical", "new_line", "same_line"],
              "markdownEnumDescriptions": [
                "Opening and closing parentheses must be on the same relative position (both on own lines or both on same line as parameters)",
                "Closing parenthesis must be on its own line",
                "Closing parenthesis must be on the same line as the last parameter"
              ]
            }
          }
        }
      ]
    },
    "Layout/MultilineMethodParameterLineBreaks": {
      "markdownDescription": "Enforces line breaks in multi-line method parameters. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutmultilinemethodparameterlinebreaks)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultilineFinalElement": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/MultilineOperationIndentation": {
      "markdownDescription": "Enforces consistent indentation for multi-line operations. Improves alignment. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layout/multilineoperationindentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["aligned", "indented"],
              "markdownEnumDescriptions": [
                "Align continued operations with the first operation",
                "Indent continued operations with a fixed indentation"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/ParameterAlignment": {
      "markdownDescription": "Enforces alignment of method parameters. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutparameteralignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["with_first_parameter", "with_fixed_indentation"],
              "markdownEnumDescriptions": [
                "Align parameters with the first parameter",
                "Use a fixed indentation for all parameters"
              ]
            },
            "IndentationWidth": {
              "type": ["integer", "null"]
            }
          }
        }
      ]
    },
    "Layout/RedundantLineBreak": {
      "markdownDescription": "Detects unnecessary line breaks. Removes useless formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutredundantlinebreak)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "InspectBlocks": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/RescueEnsureAlignment": {
      "markdownDescription": "Enforces alignment of rescue/ensure blocks. Improves code structure. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutrescueensurealignment)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SingleLineBlockChain": {
      "markdownDescription": "Enforces line breaks in block chains. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutsinglelineblockchain)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAfterColon": {
      "markdownDescription": "Enforces space after colons in hashes. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceaftercolon)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAfterComma": {
      "markdownDescription": "Enforces space after commas. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceaftercomma)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAfterMethodName": {
      "markdownDescription": "Enforces no space after method name in definition. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceaftermethodname)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAfterNot": {
      "markdownDescription": "Enforces no space after ! operator. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceafternot)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAfterSemicolon": {
      "markdownDescription": "Enforces space after semicolons. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceaftersemicolon)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAroundBlockParameters": {
      "markdownDescription": "Enforces spacing around block parameters. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacearoundblockparameters)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleInsidePipes": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces inside the pipes surrounding block parameters: `|  param  |`",
                "Disallow spaces inside the pipes surrounding block parameters: `|param|`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceAroundEqualsInParameterDefault": {
      "markdownDescription": "Enforces spaces around = in default parameters. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacearoundequalsinparameterdefault)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces around = in default parameter values: `def foo(bar = 1)`",
                "Disallow spaces around = in default parameter values: `def foo(bar=1)`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceAroundKeyword": {
      "markdownDescription": "Enforces spaces around keywords. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacearoundkeyword)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAroundMethodCallOperator": {
      "markdownDescription": "Enforces spacing around method call operators. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacearoundmethodcalloperator)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceAroundOperators": {
      "markdownDescription": "Enforces spaces around operators. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacearoundoperators)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowForAlignment": {
              "type": "boolean"
            },
            "EnforcedStyleForExponentOperator": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces around exponent operator: `2 ** 3`",
                "Disallow spaces around exponent operator: `2**3`"
              ]
            },
            "EnforcedStyleForRationalLiterals": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces around / in rational literals: `1 / 3r`",
                "Disallow spaces around / in rational literals: `1/3r`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceBeforeBlockBraces": {
      "markdownDescription": "Enforces space before opening brace in blocks. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforeblockbraces)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"]
            },
            "EnforcedStyleForEmptyBraces": {
              "enum": ["space", "no_space"]
            }
          }
        }
      ]
    },
    "Layout/SpaceBeforeBrackets": {
      "markdownDescription": "Enforces space before brackets. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforebrackets)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceBeforeComma": {
      "markdownDescription": "Enforces no space before commas. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforecomma)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceBeforeComment": {
      "markdownDescription": "Enforces space before inline comments. Improves comment readability. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforecomment)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceBeforeFirstArg": {
      "markdownDescription": "Enforces space before first argument. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforefirstarg)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowForAlignment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/SpaceBeforeSemicolon": {
      "markdownDescription": "Enforces no space before semicolons. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspacebeforesemicolon)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceInLambdaLiteral": {
      "markdownDescription": "Enforces proper spacing in lambda literals. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinlambdaliteral)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["require_no_space", "require_space"],
              "markdownEnumDescriptions": [
                "Disallow space between lambda arrow and parameters: `->(x) {}`",
                "Require space between lambda arrow and parameters: `-> (x) {}`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceInsideArrayLiteralBrackets": {
      "markdownDescription": "Enforces spacing inside array literal brackets. Improves formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidearrayliteralbrackets)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require a space before opening brace in blocks: `array.each {}`",
                "Disallow a space before opening brace in blocks: `array.each{}`"
              ]
            },
            "EnforcedStyleForEmptyBraces": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require a space before empty braces: `foo {}`",
                "Disallow a space before empty braces: `foo{}`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceInsideArrayPercentLiteral": {
      "markdownDescription": "Enforces spacing in array percent literals. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidearraypercentliteral)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceInsideBlockBraces": {
      "markdownDescription": "Enforces spacing inside block braces. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsideblockbraces)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces inside block braces: `{ |x| x + 1 }`",
                "Disallow spaces inside block braces: `{|x| x + 1}`"
              ]
            },
            "EnforcedStyleForEmptyBraces": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require space inside empty braces: `{ }`",
                "Disallow space inside empty braces: `{}`"
              ]
            },
            "SpaceBeforeBlockParameters": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Layout/SpaceInsideHashLiteralBraces": {
      "markdownDescription": "Enforces spacing inside hash braces. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidehashliteralbraces)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space", "compact"],
              "markdownEnumDescriptions": [
                "Require spaces inside hash braces: `{ a: 1, b: 2 }`",
                "Disallow spaces inside hash braces: `{a: 1, b: 2}`",
                "Allow spaces for alignment but not for single-line hashes: compact style"
              ]
            },
            "EnforcedStyleForEmptyBrackets": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require space inside empty braces: `{ }`",
                "Disallow space inside empty braces: `{}`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceInsideParens": {
      "markdownDescription": "Enforces no space inside parentheses. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsideparens)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space", "compact"],
              "markdownEnumDescriptions": [
                "Require spaces inside parentheses: `( 1 + 2 )`",
                "Disallow spaces inside parentheses: `(1 + 2)`",
                "Allow spaces for alignment but not for single-line expressions: compact style"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceInsidePercentLiteralDelimiters": {
      "markdownDescription": "Enforces spacing in percent literals. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidepercentliteraldelimiters)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceInsideRangeLiteral": {
      "markdownDescription": "Enforces no space in range literals. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsiderangeliteral)",
      "$ref": "#/definitions/cop"
    },
    "Layout/SpaceInsideReferenceBrackets": {
      "markdownDescription": "Enforces spacing inside reference brackets. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidereferencebrackets)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces inside reference brackets: `array[ 0 ]`",
                "Disallow spaces inside reference brackets: `array[0]`"
              ]
            },
            "EnforcedStyleForEmptyBrackets": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require space inside empty brackets: `[ ]`",
                "Disallow space inside empty brackets: `[]`"
              ]
            }
          }
        }
      ]
    },
    "Layout/SpaceInsideStringInterpolation": {
      "markdownDescription": "Enforces spacing in string interpolation. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layoutspaceinsidestringinterpolation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["space", "no_space"],
              "markdownEnumDescriptions": [
                "Require spaces inside string interpolation: `\"#{ var }\"`",
                "Disallow spaces inside string interpolation: `\"#{var}\"`"
              ]
            }
          }
        }
      ]
    },
    "Layout/TrailingEmptyLines": {
      "markdownDescription": "Enforces consistent trailing empty lines. Improves file formatting. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layouttrailingemptylines)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["final_newline", "final_blank_line"],
              "markdownEnumDescriptions": [
                "Require exactly one newline at the end of the file",
                "Require one blank line (two newlines) at the end of the file"
              ]
            }
          }
        }
      ]
    },
    "Layout/TrailingWhitespace": {
      "markdownDescription": "Detects and removes trailing whitespace. Improves code cleanliness. [Docs](https://docs.rubocop.org/rubocop/cops_layout#layouttrailingwhitespace)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowInHeredoc": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/AmbiguousAssignment": {
      "markdownDescription": "Detects ambiguous assignments that could be confusing. Suggests clarification. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousassignment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/AmbiguousBlockAssociation": {
      "markdownDescription": "Detects ambiguous block associations in method calls. Suggests adding parentheses. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousblockassociation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/AmbiguousOperator": {
      "markdownDescription": "Detects operators that could be confused with method calls. Suggests clarification. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousoperator)",
      "$ref": "#/definitions/cop"
    },
    "Lint/AmbiguousOperatorPrecedence": {
      "markdownDescription": "Detects operators with unclear precedence. Suggests using parentheses. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousoperatorprecedence)",
      "$ref": "#/definitions/cop"
    },
    "Lint/AmbiguousRange": {
      "markdownDescription": "Detects ambiguous range expressions. Suggests clarification with parentheses. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousrange)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "RequireParenthesesForMethodChains": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/AmbiguousRegexpLiteral": {
      "markdownDescription": "Detects ambiguous regexp literals. Suggests clarification. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintambiguousregexpliteral)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ArrayLiteralInRegexp": {
      "markdownDescription": "Detects array literals inside regexps which don't work as expected. Suggests proper syntax. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintarrayliteralinregexp)",
      "$ref": "#/definitions/cop"
    },
    "Lint/AssignmentInCondition": {
      "markdownDescription": "Detects assignment in conditions which might be unintended. Suggests using comparison. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintassignmentincondition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowSafeAssignment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/BigDecimalNew": {
      "markdownDescription": "Detects BigDecimal.new which is deprecated. Suggests using BigDecimal() instead. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintbigdecimalnew)",
      "$ref": "#/definitions/cop"
    },
    "Lint/BinaryOperatorWithIdenticalOperands": {
      "markdownDescription": "Detects operations with identical operands. Suggests simplification. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintbinaryoperatorwithidenticaloperands)",
      "$ref": "#/definitions/cop"
    },
    "Lint/BooleanSymbol": {
      "markdownDescription": "Detects use of :true, :false, :nil symbols. Suggests using boolean/nil values. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintbooleansymbol)",
      "$ref": "#/definitions/cop"
    },
    "Lint/CircularArgumentReference": {
      "markdownDescription": "Detects circular references in method default parameters. Prevents errors. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintcircularargumentreference)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ConstantDefinitionInBlock": {
      "markdownDescription": "Detects constant definitions inside blocks. Suggests defining at class/module level. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintconstantdefinitioninblock)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/ConstantOverwrittenInRescue": {
      "markdownDescription": "Detects constants overwritten in rescue clauses. Prevents unintended reassignment. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintconstantoverwritteninrescue)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ConstantReassignment": {
      "markdownDescription": "Detects reassignment of constants. Prevents warnings. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintconstantreassignment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ConstantResolution": {
      "markdownDescription": "Detects issues with constant resolution. Suggests proper scope. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintconstantresolution)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Only": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "Ignore": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/CopDirectiveSyntax": {
      "markdownDescription": "Detects incorrect RuboCop directives. Suggests proper syntax. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintcopdirectivesyntax)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DataDefineOverride": {
      "markdownDescription": "Disallows overriding built-in `Data` methods when using `Data.define`. Prevents accidentally redefining core behavior. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdatadefineoverride)",
      "$ref": "#/definitions/cop"
    },
    "Lint/Debugger": {
      "markdownDescription": "Checks for leftover debugging code like `binding.pry`, `byebug`, or `debugger` statements. These should typically be removed before committing code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdebugger)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "DebuggerMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "DebuggerRequires": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/DeprecatedClassMethods": {
      "markdownDescription": "Detects use of deprecated class methods. Suggests modern alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdeprecatedclassmethods)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DeprecatedConstants": {
      "markdownDescription": "Detects use of deprecated deprecated constants. Suggests using modern alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdeprecatedconstants)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "DeprecatedConstants": {
              "type": "object",
              "propertyNames": {
                "$ref": "#/definitions/constant"
              },
              "additionalProperties": {
                "properties": {
                  "Alternative": {
                    "type": "string"
                  },
                  "DeprecatedVersion": {
                    "type": "string",
                    "pattern": "^\\d+\\.\\d+(\\.\\d+)?$"
                  }
                },
                "additionalProperties": false
              }
            }
          }
        }
      ]
    },
    "Lint/DeprecatedOpenSSLConstant": {
      "markdownDescription": "Detects use of deprecated deprecated open s s l constant. Suggests using modern alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdeprecatedopensslconstant)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DisjunctiveAssignmentInConstructor": {
      "markdownDescription": "Enforces proper disjunctive assignment in constructor handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintdisjunctiveassignmentinconstructor)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateBranch": {
      "markdownDescription": "Detects duplicate duplicate branch in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatebranch)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IgnoreLiteralBranches": {
              "type": "boolean"
            },
            "IgnoreConstantBranches": {
              "type": "boolean"
            },
            "IgnoreDuplicateElseBranch": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/DuplicateCaseCondition": {
      "markdownDescription": "Detects duplicate duplicate case condition in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatecasecondition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateElsifCondition": {
      "markdownDescription": "Detects duplicate duplicate elsif condition in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicateelsifcondition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateHashKey": {
      "markdownDescription": "Detects duplicate duplicate hash key in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatehashkey)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateMagicComment": {
      "markdownDescription": "Detects duplicate duplicate magic comment in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatemagiccomment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateMatchPattern": {
      "markdownDescription": "Detects duplicate duplicate match pattern in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatematchpattern)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateMethods": {
      "markdownDescription": "Detects duplicate duplicate methods in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatemethods)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateRegexpCharacterClassElement": {
      "markdownDescription": "Detects duplicate elements in regexp character classes. Simplifies regexps. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicateregexpcharacterclasselement)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateRequire": {
      "markdownDescription": "Detects duplicate duplicate require in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicaterequire)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateRescueException": {
      "markdownDescription": "Detects duplicate duplicate rescue exception in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicaterescueexception)",
      "$ref": "#/definitions/cop"
    },
    "Lint/DuplicateSetElement": {
      "markdownDescription": "Detects duplicate duplicate set element in code. Helps keep code DRY. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintduplicatesetelement)",
      "$ref": "#/definitions/cop"
    },
    "Lint/EachWithObjectArgument": {
      "markdownDescription": "Enforces proper each with object argument handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linteachwithobjectargument)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ElseLayout": {
      "markdownDescription": "Enforces consistent layout of else statements. Improves code readability. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintelselayout)",
      "$ref": "#/definitions/cop"
    },
    "Lint/EmptyBlock": {
      "markdownDescription": "Detects empty empty block. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyblock)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            },
            "AllowEmptyLambdas": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EmptyClass": {
      "markdownDescription": "Detects empty empty class. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyclass)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EmptyConditionalBody": {
      "markdownDescription": "Detects empty empty conditional body. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyconditionalbody)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EmptyEnsure": {
      "markdownDescription": "Detects empty ensure blocks. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyensure)",
      "$ref": "#/definitions/cop"
    },
    "Lint/EmptyExpression": {
      "markdownDescription": "Detects empty expressions. Removes dead code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyexpression)",
      "$ref": "#/definitions/cop"
    },
    "Lint/EmptyFile": {
      "markdownDescription": "Detects empty empty file. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyfile)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EmptyInPattern": {
      "markdownDescription": "Detects empty empty in pattern. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyinpattern)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EmptyInterpolation": {
      "markdownDescription": "Detects empty string interpolation. Removes unnecessary syntax. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptyinterpolation)",
      "$ref": "#/definitions/cop"
    },
    "Lint/EmptyWhen": {
      "markdownDescription": "Detects empty empty when. Suggests removing or implementing properly. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintemptywhen)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/EnsureReturn": {
      "markdownDescription": "Enforces proper ensure return handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintensurereturn)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ErbNewArguments": {
      "markdownDescription": "Enforces proper erb new arguments handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linterbnewarguments)",
      "$ref": "#/definitions/cop"
    },
    "Lint/FlipFlop": {
      "markdownDescription": "Enforces proper flip flop handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintflipflop)",
      "$ref": "#/definitions/cop"
    },
    "Lint/FloatComparison": {
      "markdownDescription": "Detects direct equality comparisons with floats. Suggests epsilon-based comparisons. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintfloatcomparison)",
      "$ref": "#/definitions/cop"
    },
    "Lint/FloatOutOfRange": {
      "markdownDescription": "Enforces proper float out of range handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintfloatoutofrange)",
      "$ref": "#/definitions/cop"
    },
    "Lint/FormatParameterMismatch": {
      "markdownDescription": "Detects format string arguments that don't match specifiers. Prevents runtime errors. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintformatparametermismatch)",
      "$ref": "#/definitions/cop"
    },
    "Lint/HashCompareByIdentity": {
      "markdownDescription": "Enforces proper hash compare by identity handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linthashcomparebyidentity)",
      "$ref": "#/definitions/cop"
    },
    "Lint/HashNewWithKeywordArgumentsAsDefault": {
      "markdownDescription": "Enforces proper hash new with keyword arguments as default handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linthashnewwithkeywordargumentsasdefault)",
      "$ref": "#/definitions/cop"
    },
    "Lint/HeredocMethodCallPosition": {
      "markdownDescription": "Enforces proper heredoc method call position handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintheredocmethodcallposition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/IdentityComparison": {
      "markdownDescription": "Detects use of == for object identity; suggests using equal?. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintidentitycomparison)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ImplicitStringConcatenation": {
      "markdownDescription": "Detects accidental string concatenation. Prevents subtle bugs. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintimplicitstringconcatenation)",
      "$ref": "#/definitions/cop"
    },
    "Lint/IncompatibleIoSelectWithFiberScheduler": {
      "markdownDescription": "Warns about IO.select with Fiber scheduler. Improves async code correctness. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintincompatibleioselectwithfiberscheduler)",
      "$ref": "#/definitions/cop"
    },
    "Lint/IneffectiveAccessModifier": {
      "markdownDescription": "Enforces proper ineffective access modifier handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintineffectiveaccessmodifier)",
      "$ref": "#/definitions/cop"
    },
    "Lint/InheritException": {
      "markdownDescription": "Enforces proper inherit exception handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintinheritexception)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["standard_error", "runtime_error"],
              "markdownEnumDescriptions": [
                "Prefer inheriting from StandardError when creating custom exceptions",
                "Prefer inheriting from RuntimeError when creating custom exceptions"
              ]
            }
          }
        }
      ]
    },
    "Lint/InterpolationCheck": {
      "markdownDescription": "Enforces proper interpolation check handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintinterpolationcheck)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ItWithoutArgumentsInBlock": {
      "markdownDescription": "Enforces proper it without arguments in block handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintitwithoutargumentsinblock)",
      "$ref": "#/definitions/cop"
    },
    "Lint/LambdaWithoutLiteralBlock": {
      "markdownDescription": "Enforces proper lambda without literal block handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintlambdawithoutliteralblock)",
      "$ref": "#/definitions/cop"
    },
    "Lint/LiteralAsCondition": {
      "markdownDescription": "Detects literal values used as conditions. Removes dead code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintliteralascondition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/LiteralAssignmentInCondition": {
      "markdownDescription": "Enforces proper literal assignment in condition handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintliteralassignmentincondition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/LiteralInInterpolation": {
      "markdownDescription": "Enforces proper literal in interpolation handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintliteralininterpolation)",
      "$ref": "#/definitions/cop"
    },
    "Lint/Loop": {
      "markdownDescription": "Enforces proper loop handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintloop)",
      "$ref": "#/definitions/cop"
    },
    "Lint/MissingCopEnableDirective": {
      "markdownDescription": "Detects cop disable without corresponding enable. Prevents permanently disabled cops. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintmissingcopenabledirective)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MaximumRangeSize": {
              "type": "number"
            }
          }
        }
      ]
    },
    "Lint/MissingSuper": {
      "markdownDescription": "Detects missing missing super. Ensures required elements are present. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintmissingsuper)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedParentClasses": {
              "$ref": "#/definitions/constants"
            }
          }
        }
      ]
    },
    "Lint/MixedCaseRange": {
      "markdownDescription": "Enforces proper mixed case range handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintmixedcaserange)",
      "$ref": "#/definitions/cop"
    },
    "Lint/MixedRegexpCaptureTypes": {
      "markdownDescription": "Enforces proper mixed regexp capture types handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintmixedregexpcapturetypes)",
      "$ref": "#/definitions/cop"
    },
    "Lint/MultipleComparison": {
      "markdownDescription": "Detects multiple comparisons in single if. Suggests using case/in. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintmultiplecomparison)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NestedMethodDefinition": {
      "markdownDescription": "Enforces proper nested method definition handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnestedmethoddefinition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/NestedPercentLiteral": {
      "markdownDescription": "Detects nested percent literals that can cause issues. Suggests alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnestedpercentliteral)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NextWithoutAccumulator": {
      "markdownDescription": "Detects next without accumulator in reduce/inject. Prevents logic errors. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnextwithoutaccumulator)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NoReturnInBeginEndBlocks": {
      "markdownDescription": "Enforces proper no return in begin end blocks handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnoreturninbeginendblocks)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NonAtomicFileOperation": {
      "markdownDescription": "Enforces proper non atomic file operation handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnonatomicfileoperation)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NonDeterministicRequireOrder": {
      "markdownDescription": "Detects require statements that depend on load order. Improves reliability. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnondeterministicrequireorder)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NonLocalExitFromIterator": {
      "markdownDescription": "Detects return/break in iterator blocks. Suggests proper alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnonlocalexitfromiterator)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NumberConversion": {
      "markdownDescription": "Detects implicit string-to-number conversions. Prevents unexpected behavior. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnumberconversion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "IgnoredClasses": {
              "$ref": "#/definitions/constants"
            }
          }
        }
      ]
    },
    "Lint/NumberedParameterAssignment": {
      "markdownDescription": "Enforces proper numbered parameter assignment handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnumberedparameterassignment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/NumericOperationWithConstantResult": {
      "markdownDescription": "Enforces proper numeric operation with constant result handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintnumericoperationwithconstantresult)",
      "$ref": "#/definitions/cop"
    },
    "Lint/OrAssignmentToConstant": {
      "markdownDescription": "Detects ||= used with constants. Prevents constant reassignment warnings. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintorassignmenttoconstant)",
      "$ref": "#/definitions/cop"
    },
    "Lint/OrderedMagicComments": {
      "markdownDescription": "Enforces proper order of magic comments. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintorderedmagiccomments)",
      "$ref": "#/definitions/cop"
    },
    "Lint/OutOfRangeRegexpRef": {
      "markdownDescription": "Enforces proper out of range regexp ref handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintoutofrangeregexpref)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ParenthesesAsGroupedExpression": {
      "markdownDescription": "Enforces proper parentheses as grouped expression handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintparenthesesasgroupedexpression)",
      "$ref": "#/definitions/cop"
    },
    "Lint/PercentStringArray": {
      "markdownDescription": "Detects %w()/%W() with unintended escapes. Suggests raw strings. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintpercentstringarray)",
      "$ref": "#/definitions/cop"
    },
    "Lint/PercentSymbolArray": {
      "markdownDescription": "Enforces proper percent symbol array handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintpercentsymbolarray)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RaiseException": {
      "markdownDescription": "Enforces proper raise exception handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintraiseexception)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedImplicitNamespaces": {
              "$ref": "#/definitions/constants"
            }
          }
        }
      ]
    },
    "Lint/RandOne": {
      "markdownDescription": "Detects rand(1) which always returns 0. Suggests alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrandone)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantCopDisableDirective": {
      "markdownDescription": "Detects redundant redundant cop disable directive. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantcopdisabledirective)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantCopEnableDirective": {
      "markdownDescription": "Detects redundant redundant cop enable directive. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantcopenabledirective)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantDirGlobSort": {
      "markdownDescription": "Detects redundant redundant dir glob sort. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantdirglobsort)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantRegexpQuantifiers": {
      "markdownDescription": "Detects redundant redundant regexp quantifiers. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantregexpquantifiers)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantRequireStatement": {
      "markdownDescription": "Detects redundant redundant require statement. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantrequirestatement)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantSafeNavigation": {
      "markdownDescription": "Detects redundant redundant safe navigation. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantsafenavigation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "InferNonNilReceiver": {
              "type": "boolean"
            },
            "AdditionalNilMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/RedundantSplatExpansion": {
      "markdownDescription": "Detects redundant redundant splat expansion. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantsplatexpansion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowPercentLiteralArrayArgument": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/RedundantStringCoercion": {
      "markdownDescription": "Detects redundant redundant string coercion. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantstringcoercion)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantTypeConversion": {
      "markdownDescription": "Detects redundant redundant type conversion. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundanttypeconversion)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantWithIndex": {
      "markdownDescription": "Detects redundant redundant with index. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantwithindex)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RedundantWithObject": {
      "markdownDescription": "Detects redundant redundant with object. Removes duplicate code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintredundantwithobject)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RefinementImportMethods": {
      "markdownDescription": "Enforces proper refinement import methods handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrefinementimportmethods)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RegexpAsCondition": {
      "markdownDescription": "Enforces proper regexp as condition handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintregexpascondition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RequireParentheses": {
      "markdownDescription": "Enforces proper require parentheses handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrequireparentheses)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RequireRangeParentheses": {
      "markdownDescription": "Enforces proper require range parentheses handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrequirerangeparentheses)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RequireRelativeSelfPath": {
      "markdownDescription": "Enforces proper require relative self path handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrequirerelativeselfpath)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RescueException": {
      "markdownDescription": "Detects bare rescue catching Exception. Suggests StandardError instead. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrescueexception)",
      "$ref": "#/definitions/cop"
    },
    "Lint/RescueType": {
      "markdownDescription": "Detects invalid exception types in rescue. Prevents runtime errors. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintrescuetype)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ReturnInVoidContext": {
      "markdownDescription": "Detects explicit returns in setter methods. Prevents confusion. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintreturninvoidcontext)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SafeNavigationChain": {
      "markdownDescription": "Detects chains of safe navigation that can be simplified. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsafenavigationchain)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/SafeNavigationConsistency": {
      "markdownDescription": "Enforces proper safe navigation consistency handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsafenavigationconsistency)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/SafeNavigationWithEmpty": {
      "markdownDescription": "Detects safe navigation with empty? which could fail. Prevents bugs. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsafenavigationwithempty)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ScriptPermission": {
      "markdownDescription": "Checks script file permissions. Ensures proper executable flags. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintscriptpermission)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SelfAssignment": {
      "markdownDescription": "Enforces proper self assignment handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintselfassignment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SendWithMixinArgument": {
      "markdownDescription": "Enforces proper send with mixin argument handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsendwithmixinargument)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ShadowedArgument": {
      "markdownDescription": "Detects shadowing of method arguments in blocks. Prevents confusion. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintshadowedargument)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IgnoreImplicitReferences": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/ShadowedException": {
      "markdownDescription": "Enforces proper shadowed exception handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintshadowedexception)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ShadowingOuterLocalVariable": {
      "markdownDescription": "Checks for block or lambda parameters that shadow outer local variables. This can lead to confusing code where it's unclear which variable is being referenced. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintshadowingouterlocalvariable)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SharedMutableDefault": {
      "markdownDescription": "Enforces proper shared mutable default handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsharedmutabledefault)",
      "$ref": "#/definitions/cop"
    },
    "Lint/StructNewOverride": {
      "markdownDescription": "Enforces proper struct new override handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintstructnewoverride)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SuppressedException": {
      "markdownDescription": "Detects rescue clauses that suppress exceptions silently. Improves error visibility. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsuppressedexception)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            },
            "AllowNil": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/SuppressedExceptionInNumberConversion": {
      "markdownDescription": "Enforces proper suppressed exception in number conversion handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsuppressedexceptioninnumberconversion)",
      "$ref": "#/definitions/cop"
    },
    "Lint/SymbolConversion": {
      "markdownDescription": "Detects unnecessary symbol conversions. Simplifies code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsymbolconversion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["strict", "consistent"],
              "markdownEnumDescriptions": [
                "Always enforce the preferred symbol syntax (e.g., :symbol over :'symbol')",
                "Allow quoted symbols when all symbols in a collection use quotes for consistency"
              ]
            }
          }
        }
      ]
    },
    "Lint/Syntax": {
      "markdownDescription": "Enforces proper syntax handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintsyntax)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ToEnumArguments": {
      "markdownDescription": "Enforces proper to enum arguments handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linttoenumarguments)",
      "$ref": "#/definitions/cop"
    },
    "Lint/ToJSON": {
      "markdownDescription": "Detects to_json calls without explicit handling. Prevents serialization issues. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linttojson)",
      "$ref": "#/definitions/cop"
    },
    "Lint/TopLevelReturnWithArgument": {
      "markdownDescription": "Detects return with arguments at top level. Prevents unintended behavior. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linttoplevelreturnwithargument)",
      "$ref": "#/definitions/cop"
    },
    "Lint/TrailingCommaInAttributeDeclaration": {
      "markdownDescription": "Detects trailing commas in attribute declarations. Prevents issues. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linttrailingcommainattributedeclaration)",
      "$ref": "#/definitions/cop"
    },
    "Lint/TripleQuotes": {
      "markdownDescription": "Enforces proper triple quotes handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linttriplequotes)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnderscorePrefixedVariableName": {
      "markdownDescription": "Detects underscore-prefixed unused variables. Suggests removing or using. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunderscoreprefixedvariablename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowKeywordBlockArguments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/UnescapedBracketInRegexp": {
      "markdownDescription": "Enforces proper unescaped bracket in regexp handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunescapedbracketinregexp)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnexpectedBlockArity": {
      "markdownDescription": "Enforces proper unexpected block arity handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunexpectedblockarity)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Methods": {
              "type": "object",
              "additionalProperties": {
                "type": "integer",
                "minimum": 0
              }
            }
          }
        }
      ]
    },
    "Lint/UnifiedInteger": {
      "markdownDescription": "Enforces proper unified integer handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunifiedinteger)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnmodifiedReduceAccumulator": {
      "markdownDescription": "Enforces proper unmodified reduce accumulator handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunmodifiedreduceaccumulator)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnreachableCode": {
      "markdownDescription": "Detects unreachable code after return/raise. Removes dead code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunreachablecode)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnreachableLoop": {
      "markdownDescription": "Detects loops that never execute. Removes dead code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunreachableloop)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/UnreachablePatternBranch": {
      "markdownDescription": "Checks for unreachable `in` branches in pattern matching after an unconditional catch-all branch. Helps keep pattern matches correct and meaningful. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunreachablepatternbranch)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UnusedBlockArgument": {
      "markdownDescription": "Detects unused block parameters. Suggests using _ prefix. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunusedblockargument)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IgnoreEmptyBlocks": {
              "type": "boolean"
            },
            "AllowUnusedKeywordArguments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Lint/UnusedMethodArgument": {
      "markdownDescription": "Checks for method parameters that are defined but never used in the method body. Unused parameters may indicate incomplete implementation or can be removed to improve code clarity. Prefix unused parameters with `_` to indicate they're intentionally unused. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintunusedmethodargument)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowUnusedKeywordArguments": {
              "type": "boolean"
            },
            "IgnoreEmptyMethods": {
              "type": "boolean"
            },
            "IgnoreNotImplementedMethods": {
              "type": "boolean"
            },
            "NotImplementedExceptions": {
              "$ref": "#/definitions/constants"
            }
          }
        }
      ]
    },
    "Lint/UriEscapeUnescape": {
      "markdownDescription": "Enforces proper uri escape unescape handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linturiescapeunescape)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UriRegexp": {
      "markdownDescription": "Enforces proper uri regexp handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#linturiregexp)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessAccessModifier": {
      "markdownDescription": "Detects access modifiers with no effect. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessaccessmodifier)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ContextCreatingMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "MethodCreatingMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/UselessAssignment": {
      "markdownDescription": "Checks for variables that are assigned values but never used. These assignments waste resources and can clutter the code, often indicating logic errors or incomplete refactoring. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessassignment)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessConstantScoping": {
      "markdownDescription": "Detects useless useless constant scoping. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessconstantscoping)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessDefaultValueArgument": {
      "markdownDescription": "Detects useless useless default value argument. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessdefaultvalueargument)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedReceivers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Lint/UselessDefined": {
      "markdownDescription": "Detects useless useless defined. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessdefined)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessElseWithoutRescue": {
      "markdownDescription": "Detects else without rescue in begin block. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselesselsewithoutrescue)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessMethodDefinition": {
      "markdownDescription": "Detects useless useless method definition. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessmethoddefinition)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessNumericOperation": {
      "markdownDescription": "Detects useless useless numeric operation. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessnumericoperation)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessOr": {
      "markdownDescription": "Detects useless useless or. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessor)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessRescue": {
      "markdownDescription": "Detects rescue that doesn't catch anything. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselessrescue)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessRuby2Keywords": {
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessSetterCall": {
      "markdownDescription": "Detects setter calls that don't change state. Removes unnecessary calls. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselesssettercall)",
      "$ref": "#/definitions/cop"
    },
    "Lint/UselessTimes": {
      "markdownDescription": "Detects times iterator used incorrectly. Suggests proper iteration. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintuselesstimes)",
      "$ref": "#/definitions/cop"
    },
    "Lint/Void": {
      "markdownDescription": "Enforces proper void handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_lint#lintvoid)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CheckForMethodsWithNoSideEffects": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Metrics/AbcSize": {
      "markdownDescription": "Calculates the ABC (Assignment, Branch, Call) metric for methods. This metric measures method complexity based on assignments, branches (conditionals), and method calls. High ABC scores suggest methods that may be doing too much and should be refactored. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsabcsize)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "CountRepeatedAttributes": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Metrics/BlockLength": {
      "markdownDescription": "Checks for blocks that are too long. Long blocks can be hard to understand and may indicate code that should be extracted into separate methods. DSL blocks (like RSpec `describe` blocks) are often excluded from this check. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsblocklength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CountComments": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            },
            "CountAsOne": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Metrics/BlockNesting": {
      "markdownDescription": "Enforces maximum nesting depth in blocks. Prevents deeply nested code. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsblocknesting)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CountBlocks": {
              "type": "boolean"
            },
            "CountModifierForms": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Metrics/ClassLength": {
      "markdownDescription": "Checks for classes that are too long. Long classes often violate the Single Responsibility Principle and can be difficult to understand and maintain. Consider splitting them into multiple smaller classes. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsclasslength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CountComments": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            },
            "CountAsOne": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Metrics/CollectionLiteralLength": {
      "markdownDescription": "Enforces maximum collection literal length. Prevents overly long literals. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricscollectionliterallength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "LengthThreshold": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Metrics/CyclomaticComplexity": {
      "markdownDescription": "Measures cyclomatic complexity, which counts the number of linearly independent paths through a method. High cyclomatic complexity indicates methods with many conditional branches that are difficult to test and understand. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricscyclomaticcomplexity)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Metrics/MethodLength": {
      "markdownDescription": "Checks for methods that are too long. Long methods are harder to understand, test, and maintain. Consider breaking them into smaller, more focused methods. The default maximum is typically 10 lines. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsmethodlength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CountComments": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            },
            "CountAsOne": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Metrics/ModuleLength": {
      "markdownDescription": "Enforces maximum module length. Encourages splitting into multiple modules. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsmodulelength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CountComments": {
              "type": "boolean"
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            },
            "CountAsOne": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Metrics/ParameterLists": {
      "markdownDescription": "Enforces maximum number of parameters. Suggests using options hash or struct. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsparameterlists)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Max": {
              "type": "integer",
              "minimum": 0
            },
            "CountKeywordArgs": {
              "type": "boolean"
            },
            "MaxOptionalParameters": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Metrics/PerceivedComplexity": {
      "markdownDescription": "Enforces limit on perceived complexity. Prevents confusing logic. [Docs](https://docs.rubocop.org/rubocop/cops_metrics#metricsperceivedcomplexity)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Migration/DepartmentName": {
      "$ref": "#/definitions/cop"
    },
    "Naming/AccessorMethodName": {
      "markdownDescription": "Enforces proper naming for accessor methods. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingaccessormethodname)",
      "$ref": "#/definitions/cop"
    },
    "Naming/AsciiIdentifiers": {
      "markdownDescription": "Enforces ASCII-only identifiers. Improves code compatibility. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingasciiidentifiers)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AsciiConstants": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Naming/BinaryOperatorParameterName": {
      "markdownDescription": "Enforces proper naming for binary operator parameters. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingbinaryoperatorparametername)",
      "$ref": "#/definitions/cop"
    },
    "Naming/BlockForwarding": {
      "markdownDescription": "Enforces consistent block forwarding syntax. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingblockforwarding)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["anonymous", "explicit"],
              "markdownEnumDescriptions": [
                "Use anonymous block forwarding: `def foo(&); bar(&); end`",
                "Use explicit block parameter name: `def foo(&block); bar(&block); end`"
              ]
            },
            "BlockForwardingName": {
              "type": "string"
            }
          }
        }
      ]
    },
    "Naming/BlockParameterName": {
      "markdownDescription": "Enforces proper naming for block parameters. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingblockparametername)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinNameLength": {
              "type": "integer",
              "minimum": 0
            },
            "AllowNamesEndingInNumbers": {
              "type": "boolean"
            },
            "AllowedNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/ClassAndModuleCamelCase": {
      "markdownDescription": "Enforces CamelCase for classes and modules. Follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingclassandmodulecamelcase)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/ConstantName": {
      "markdownDescription": "Enforces CONSTANT_CASE for constants. Follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingconstantname)",
      "$ref": "#/definitions/cop"
    },
    "Naming/FileName": {
      "markdownDescription": "Enforces filename matches class/module name. Improves project organization. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingfilename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ExpectMatchingDefinition": {
              "type": "boolean"
            },
            "CheckDefinitionPathHierarchy": {
              "type": "boolean"
            },
            "CheckDefinitionPathHierarchyRoots": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "Regex": {
              "type": "string"
            },
            "IgnoreExecutableScripts": {
              "type": "boolean"
            },
            "AllowedAcronyms": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string",
                "pattern": "^[A-Z0-9]+$"
              }
            }
          }
        }
      ]
    },
    "Naming/HeredocDelimiterCase": {
      "markdownDescription": "Enforces consistent heredoc delimiter casing. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingheredocdelimitercase)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["lowercase", "uppercase"],
              "markdownEnumDescriptions": [
                "Prefer lowercase heredoc delimiters: `<<~html`",
                "Prefer uppercase heredoc delimiters: `<<~HTML`"
              ]
            }
          }
        }
      ]
    },
    "Naming/HeredocDelimiterNaming": {
      "markdownDescription": "Enforces proper naming for heredoc delimiters. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingheredocdelimiternaming)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ForbiddenDelimiters": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/InclusiveLanguage": {
      "markdownDescription": "Encourages inclusive terminology in code. Promotes inclusive practices. [Docs](https://docs.rubocop.org/rubocop/cops_naming#naminginclusivelanguage)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "CheckIdentifiers": {
              "type": "boolean"
            },
            "CheckConstants": {
              "type": "boolean"
            },
            "CheckVariables": {
              "type": "boolean"
            },
            "CheckStrings": {
              "type": "boolean"
            },
            "CheckSymbols": {
              "type": "boolean"
            },
            "CheckComments": {
              "type": "boolean"
            },
            "CheckFilepaths": {
              "type": "boolean"
            },
            "FlaggedTerms": {
              "type": "object",
              "additionalProperties": {
                "type": "object",
                "properties": {
                  "Regex": {
                    "type": "string"
                  },
                  "Suggestions": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "array",
                        "uniqueItems": true,
                        "items": {
                          "type": "string"
                        }
                      }
                    ]
                  },
                  "WholeWord": {
                    "type": "boolean"
                  }
                },
                "required": ["Suggestions"]
              }
            }
          }
        }
      ]
    },
    "Naming/MemoizedInstanceVariableName": {
      "markdownDescription": "Enforces proper naming for memoized variables. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingmemoizedinstancevariablename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleForLeadingUnderscores": {
              "enum": ["disallowed", "required", "optional"],
              "markdownEnumDescriptions": [
                "Disallow leading underscores in memoized instance variable names",
                "Require leading underscores in memoized instance variable names",
                "Allow either with or without leading underscores in memoized instance variable names"
              ]
            }
          }
        }
      ]
    },
    "Naming/MethodName": {
      "markdownDescription": "Enforces snake_case for method names. Follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingmethodname)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["snake_case", "camelCase"],
              "markdownEnumDescriptions": [
                "Enforce snake_case for method names: `def my_method`",
                "Enforce camelCase for method names: `def myMethod`"
              ]
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenIdentifiers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/MethodParameterName": {
      "markdownDescription": "Enforces proper naming for method parameters. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingmethodparametername)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinNameLength": {
              "type": "integer",
              "minimum": 0
            },
            "AllowNamesEndingInNumbers": {
              "type": "boolean"
            },
            "AllowedNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/PredicateMethod": {
      "markdownDescription": "Enforces proper predicate method handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingpredicatemethod)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Mode": {
              "enum": ["conservative", "aggressive"],
              "markdownEnumDescriptions": [
                "Only check methods with is_, has_, or have_ prefixes",
                "Check all methods that return boolean values for proper ? suffix"
              ]
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowBangMethods": {
              "type": "boolean"
            },
            "WaywardPredicates": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/PredicatePrefix": {
      "markdownDescription": "Enforces proper predicate prefix handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingpredicateprefix)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "NamePrefix": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenPrefixes": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "MethodDefinitionMacros": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "UseSorbetSigs": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Naming/RescuedExceptionsVariableName": {
      "markdownDescription": "Enforces proper naming for rescue variables. Improves clarity. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingrescuedexceptionsvariablename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "PreferredName": {
              "type": "string",
              "minLength": 1
            }
          }
        }
      ]
    },
    "Naming/VariableName": {
      "markdownDescription": "Enforces snake_case for variables. Follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingvariablename)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["snake_case", "camelCase"],
              "markdownEnumDescriptions": [
                "Enforce snake_case for variable names: `my_variable`",
                "Enforce camelCase for variable names: `myVariable`"
              ]
            },
            "AllowedIdentifiers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenIdentifiers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "ForbiddenPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Naming/VariableNumber": {
      "markdownDescription": "Enforces proper numbering for variables. Improves consistency. [Docs](https://docs.rubocop.org/rubocop/cops_naming#namingvariablenumber)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["snake_case", "normalcase", "non_integer"],
              "markdownEnumDescriptions": [
                "Enforce snake_case for variables with numbers: `variable_1`",
                "Enforce numbers directly after name: `variable1`",
                "Disallow integer suffixes in variable names"
              ]
            },
            "CheckMethodNames": {
              "type": "boolean"
            },
            "CheckSymbols": {
              "type": "boolean"
            },
            "AllowedIdentifiers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Security/CompoundHash": {
      "markdownDescription": "Detects compound hash methods that could have security issues. Suggests alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_security#securitycompoundhash)",
      "$ref": "#/definitions/cop"
    },
    "Security/Eval": {
      "markdownDescription": "Detects eval usage which is a security risk. Suggests safer alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_security#securityeval)",
      "$ref": "#/definitions/cop"
    },
    "Security/IoMethods": {
      "markdownDescription": "Detects IO methods that might have security implications. Suggests proper input validation. [Docs](https://docs.rubocop.org/rubocop/cops_security#securityiomethods)",
      "$ref": "#/definitions/cop"
    },
    "Security/JSONLoad": {
      "markdownDescription": "Detects JSON.load which can deserialize arbitrary objects. Suggests JSON.parse instead. [Docs](https://docs.rubocop.org/rubocop/cops_security#securityjsonload)",
      "$ref": "#/definitions/cop"
    },
    "Security/MarshalLoad": {
      "markdownDescription": "Detects Marshal.load which can deserialize arbitrary objects. Suggests safer alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_security#securitymarshalload)",
      "$ref": "#/definitions/cop"
    },
    "Security/YAMLLoad": {
      "markdownDescription": "Detects YAML.load which can deserialize arbitrary objects. Suggests YAML.safe_load instead. [Docs](https://docs.rubocop.org/rubocop/cops_security#securityyamlload)",
      "$ref": "#/definitions/cop"
    },
    "Style/AccessModifierDeclarations": {
      "markdownDescription": "Enforces consistent style for access modifier declarations (`private`, `protected`, `public`). Can require inline modifiers (e.g., `private def foo`) or group style (e.g., `private` on its own line). [Docs](https://docs.rubocop.org/rubocop/cops_style#styleaccessmodifierdeclarations)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["inline", "group"],
              "markdownEnumDescriptions": [
                "Require inline access modifiers: `private def foo`",
                "Require grouped access modifiers: `private` on its own line followed by methods"
              ]
            },
            "AllowModifiersOnSymbols": {
              "type": "boolean"
            },
            "AllowModifiersOnAttrs": {
              "type": "boolean"
            },
            "AllowModifiersOnAliasMethod": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/AccessorGrouping": {
      "markdownDescription": "Enforces grouping or separation of accessor methods (`attr_reader`, `attr_writer`, `attr_accessor`). Can require grouping multiple accessors on one line or separating them. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleaccessorgrouping)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["separated", "grouped"],
              "markdownEnumDescriptions": [
                "Require separate accessor declarations: `attr_reader :foo` and `attr_reader :bar` on different lines",
                "Allow grouping accessors: `attr_reader :foo, :bar` on one line"
              ]
            }
          }
        }
      ]
    },
    "Style/Alias": {
      "markdownDescription": "Enforces consistent use of `alias` vs `alias_method`. The `alias` keyword is faster but has different scoping rules than `alias_method`. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylealias)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["prefer_alias", "prefer_alias_method"],
              "markdownEnumDescriptions": [
                "Prefer the `alias` keyword: `alias new_name old_name`",
                "Prefer the `alias_method` method: `alias_method :new_name, :old_name`"
              ]
            }
          }
        }
      ]
    },
    "Style/AmbiguousEndlessMethodDefinition": {
      "markdownDescription": "Checks for ambiguous endless method definitions that require parentheses for clarity. Prevents confusion in Ruby 3.0+ endless method syntax. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleambiguousendlessmethoddefinition)",
      "$ref": "#/definitions/cop"
    },
    "Style/AndOr": {
      "markdownDescription": "Checks for uses of `and`/`or` and suggests using `&&`/`||` instead. The keywords have different precedence which can lead to subtle bugs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleandor)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["always", "conditionals"],
              "markdownEnumDescriptions": [
                "Always disallow `and`/`or` keywords in favor of `&&`/`||`",
                "Only disallow `and`/`or` in conditionals, allow in control flow (e.g., `do_something or raise 'error'`)"
              ]
            }
          }
        }
      ]
    },
    "Style/ArgumentsForwarding": {
      "markdownDescription": "Enforces use of Ruby 2.7+ argument forwarding syntax (`...`) when all arguments are forwarded to another method. Improves readability and performance. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleargumentsforwarding)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowOnlyRestArgument": {
              "type": "boolean"
            },
            "UseAnonymousForwarding": {
              "type": "boolean"
            },
            "RedundantRestArgumentNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "RedundantKeywordRestArgumentNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "RedundantBlockArgumentNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/ArrayCoercion": {
      "markdownDescription": "Checks for uses of `Array()` and suggests using `Array.wrap()` or explicit array coercion. Helps avoid unexpected behavior with arrays that respond to `to_a`. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylearraycoercion)",
      "$ref": "#/definitions/cop"
    },
    "Style/ArrayFirstLast": {
      "markdownDescription": "Enforces use of `first` and `last` methods instead of array indexing (`[0]`, `[-1]`) for better readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylearrayfirstlast)",
      "$ref": "#/definitions/cop"
    },
    "Style/ArrayIntersect": {
      "markdownDescription": "Enforces use of `Array#intersect?` (Ruby 3.1+) instead of `(array1 & array2).any?` for checking if arrays have common elements. More efficient and readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylearrayintersect)",
      "$ref": "#/definitions/cop"
    },
    "Style/ArrayIntersectWithSingleElement": {
      "markdownDescription": "Checks for array intersection with a single element array and suggests using `include?` instead. More idiomatic and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylearrayintersectwithsingleelement)",
      "$ref": "#/definitions/cop"
    },
    "Style/ArrayJoin": {
      "markdownDescription": "Enforces use of `Array#join` instead of `Array#*` with a string argument for joining array elements. More explicit and readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylearrayjoin)",
      "$ref": "#/definitions/cop"
    },
    "Style/AsciiComments": {
      "markdownDescription": "Checks for non-ASCII characters in comments. Useful for projects that require ASCII-only source code for compatibility reasons. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleasciicomments)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedChars": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/Attr": {
      "markdownDescription": "Checks for obsolete `attr` usage and suggests using `attr_reader` or `attr_accessor` instead. The `attr` method is deprecated. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleattr)",
      "$ref": "#/definitions/cop"
    },
    "Style/AutoResourceCleanup": {
      "markdownDescription": "Enforces use of blocks with automatic resource cleanup (e.g., `File.open` with a block) to prevent resource leaks. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleautoresourcecleanup)",
      "$ref": "#/definitions/cop"
    },
    "Style/BarePercentLiterals": {
      "markdownDescription": "Enforces consistent style for bare percent literals. Choose between `%q` (explicit) or `%` (bare) for string literals. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylebarepercentliterals)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["percent_q", "bare_percent"],
              "markdownEnumDescriptions": [
                "Prefer explicit percent literal: `%q(string)`",
                "Prefer bare percent literal: `%(string)`"
              ]
            }
          }
        }
      ]
    },
    "Style/BeginBlock": {
      "markdownDescription": "Checks for use of `BEGIN` blocks, which are rarely needed and can make code harder to understand. Avoid using them unless absolutely necessary. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylebeginblock)",
      "$ref": "#/definitions/cop"
    },
    "Style/BisectedAttrAccessor": {
      "markdownDescription": "Checks for separate `attr_reader` and `attr_writer` declarations that can be combined into a single `attr_accessor`. Reduces boilerplate. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylebisectedattraccessor)",
      "$ref": "#/definitions/cop"
    },
    "Style/BitwisePredicate": {
      "markdownDescription": "Checks for bitwise operations that can be replaced with simpler predicate methods like `odd?` or `even?`. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylebitwisepredicate)",
      "$ref": "#/definitions/cop"
    },
    "Style/BlockComments": {
      "markdownDescription": "Checks for block comments (`=begin`/`=end`) and suggests using line comments (`#`) instead. Block comments are rarely used in Ruby. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleblockcomments)",
      "$ref": "#/definitions/cop"
    },
    "Style/BlockDelimiters": {
      "markdownDescription": "Enforces consistent use of `do...end` vs `{...}` for blocks. Common styles: use braces for single-line/chaining, `do...end` for multi-line/procedural methods. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleblockdelimiters)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "type": "string",
              "enum": [
                "line_count_based",
                "semantic",
                "braces_for_chaining",
                "always_braces"
              ],
              "markdownEnumDescriptions": [
                "Use braces for single-line blocks, do...end for multi-line blocks",
                "Use braces for functional methods (map, select), do...end for procedural methods (each, tap)",
                "Use braces when chaining methods, do...end otherwise",
                "Always use braces for blocks"
              ]
            },
            "ProceduralMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "FunctionalMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowBracesOnProceduralOneLiners": {
              "type": "boolean"
            },
            "BracesRequiredMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/CaseEquality": {
      "markdownDescription": "Checks for explicit use of the case equality operator (`===`). Usually you should use `case/when` statements instead for better readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecaseequality)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowOnConstant": {
              "type": "boolean"
            },
            "AllowOnSelfClass": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/CaseLikeIf": {
      "markdownDescription": "Checks for `if/elsif` chains that compare the same variable and suggests using a `case/when` statement instead. More readable and maintainable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecaselikeif)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinBranchesCount": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/CharacterLiteral": {
      "markdownDescription": "Checks for character literals (`?x`) and suggests using string literals (`'x'`) instead. Character literals are a legacy Ruby feature. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecharacterliteral)",
      "$ref": "#/definitions/cop"
    },
    "Style/ClassAndModuleChildren": {
      "markdownDescription": "Enforces consistent style for nested class/module definitions. Choose between compact (`class Foo::Bar`) or nested (`class Foo; class Bar`) style. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclassandmodulechildren)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["nested", "compact"],
              "markdownEnumDescriptions": [
                "Prefer nested style: `class Foo\n  class Bar\n  end\nend`",
                "Prefer compact style: `class Foo::Bar`"
              ]
            },
            "EnforcedStyleForClasses": {
              "enum": [null, "nested", "compact"],
              "markdownEnumDescriptions": [
                "Use the general EnforcedStyle setting",
                "Prefer nested style for classes only",
                "Prefer compact style for classes only"
              ]
            },
            "EnforcedStyleForModules": {
              "enum": [null, "nested", "compact"],
              "markdownEnumDescriptions": [
                "Use the general EnforcedStyle setting",
                "Prefer nested style for modules only",
                "Prefer compact style for modules only"
              ]
            }
          }
        }
      ]
    },
    "Style/ClassCheck": {
      "markdownDescription": "Enforces consistent use of `is_a?` vs `kind_of?` for class type checking. Both methods are functionally identical. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclasscheck)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["is_a?", "kind_of?"],
              "markdownEnumDescriptions": [
                "Prefer `is_a?` for type checking: `obj.is_a?(String)`",
                "Prefer `kind_of?` for type checking: `obj.kind_of?(String)`"
              ]
            }
          }
        }
      ]
    },
    "Style/ClassEqualityComparison": {
      "markdownDescription": "Checks for class equality comparisons using `==` and suggests using `is_a?`, `kind_of?`, or `instance_of?` instead. More idiomatic and handles inheritance better. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclassequalitycomparison)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/ClassMethods": {
      "markdownDescription": "Enforces use of `def self.method` instead of `def ClassName.method` for defining class methods. Using `self` is more maintainable when refactoring. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclassmethods)",
      "$ref": "#/definitions/cop"
    },
    "Style/ClassMethodsDefinitions": {
      "markdownDescription": "Enforces consistent style for defining class methods. Choose between `def self.method` or `class << self` style. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclassmethodsdefinitions)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["def_self", "self_class"],
              "markdownEnumDescriptions": [
                "Prefer `def self.method_name` style for class methods",
                "Prefer `class << self` style for class methods"
              ]
            }
          }
        }
      ]
    },
    "Style/ClassVars": {
      "markdownDescription": "Checks for class variables (`@@var`) and suggests using class instance variables instead. Class variables have surprising inheritance behavior and can cause bugs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleclassvars)",
      "$ref": "#/definitions/cop"
    },
    "Style/CollectionCompact": {
      "markdownDescription": "Enforces use of `compact` instead of `reject(&:nil?)` or `select { |e| !e.nil? }` for removing nil values from collections. More concise and idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecollectioncompact)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedReceivers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/CollectionMethods": {
      "markdownDescription": "Enforces use of preferred collection method names. For example, prefer `map` over `collect`, or `find` over `detect`. Improves consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecollectionmethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "PreferredMethods": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            },
            "MethodsAcceptingSymbol": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/CollectionQuerying": {
      "markdownDescription": "Enforces proper collection querying handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style.html#stylecollectionquerying)",
      "$ref": "#/definitions/cop"
    },
    "Style/ColonMethodCall": {
      "markdownDescription": "Checks for use of `::` for method calls (e.g., `Foo::bar()`) and suggests using `.` instead. The `::` syntax should only be used for constants. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecolonmethodcall)",
      "$ref": "#/definitions/cop"
    },
    "Style/ColonMethodDefinition": {
      "markdownDescription": "Checks for method definitions using `::` (e.g., `def self::foo`) and suggests using `.` instead. This syntax is rarely used and confusing. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecolonmethoddefinition)",
      "$ref": "#/definitions/cop"
    },
    "Style/CombinableDefined": {
      "markdownDescription": "Checks for multiple `defined?` calls that can be combined into a single check with logical operators. More concise and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecombinabledefined)",
      "$ref": "#/definitions/cop"
    },
    "Style/CombinableLoops": {
      "markdownDescription": "Checks for consecutive loops over the same collection that can be combined into a single loop. Improves performance and readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecombinableloops)",
      "$ref": "#/definitions/cop"
    },
    "Style/CommandLiteral": {
      "markdownDescription": "Enforces consistent style for command literals (shell commands). Choose between backticks or `%x()` syntax. Backticks are more common. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecommandliteral)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["backticks", "percent_x", "mixed"],
              "markdownEnumDescriptions": [
                "Prefer backticks for command literals: `` `ls` ``",
                "Prefer %x() syntax for command literals: `%x(ls)`",
                "Allow both backticks and %x() syntax"
              ]
            },
            "AllowInnerBackticks": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/CommentAnnotation": {
      "markdownDescription": "Enforces consistent formatting for comment annotations like `TODO`, `FIXME`, `OPTIMIZE`, etc. Ensures they follow a standard format with colons. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecommentannotation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Keywords": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "RequireColon": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/CommentedKeyword": {
      "markdownDescription": "Checks for comments placed on the same line as keywords like `end`, `else`, `elsif`. Comments should go on the line before. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecommentedkeyword)",
      "$ref": "#/definitions/cop"
    },
    "Style/ComparableBetween": {
      "markdownDescription": "Enforces use of `Comparable#between?` instead of manual range checks like `x >= min && x <= max`. More readable and concise. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecomparablebetween)",
      "$ref": "#/definitions/cop"
    },
    "Style/ComparableClamp": {
      "markdownDescription": "Enforces use of `Comparable#clamp` (Ruby 2.4+) instead of manual min/max logic. More readable and efficient for constraining values to a range. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecomparableclamp)",
      "$ref": "#/definitions/cop"
    },
    "Style/ConcatArrayLiterals": {
      "markdownDescription": "Checks for array concatenation with literal arrays and suggests using a single array literal instead. For example, `[1, 2] + [3, 4]` should be `[1, 2, 3, 4]`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleconcatarrayliterals)",
      "$ref": "#/definitions/cop"
    },
    "Style/ConditionalAssignment": {
      "markdownDescription": "Enforces consistent style for conditional variable assignment. Choose between assigning to the condition result or assigning inside each branch. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleconditionalassignment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["assign_to_condition", "assign_inside_condition"],
              "markdownEnumDescriptions": [
                "Assign the result of the condition: `x = if condition then a else b end`",
                "Assign inside each branch: `if condition then x = a else x = b end`"
              ]
            },
            "SingleLineConditionsOnly": {
              "type": "boolean"
            },
            "IncludeTernaryExpressions": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/ConstantVisibility": {
      "markdownDescription": "Enforces explicit visibility declarations (`private_constant`, `public_constant`) for constants. Helps document and enforce which constants are part of the public API. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleconstantvisibility)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IgnoreModules": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/Copyright": {
      "markdownDescription": "Checks that source files include a copyright notice matching a specified pattern. Useful for ensuring license compliance. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylecopyright)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Notice": {
              "type": "string"
            },
            "AutocorrectNotice": {
              "type": "string"
            }
          }
        }
      ]
    },
    "Style/DataInheritance": {
      "markdownDescription": "Checks for classes inheriting from `Data.define`. Classes should not inherit from Data objects as they're meant to be final value objects. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledatainheritance)",
      "$ref": "#/definitions/cop"
    },
    "Style/DateTime": {
      "markdownDescription": "Checks for uses of `DateTime` class and suggests using `Time` or `Date` instead. `DateTime` is rarely needed and has worse performance than `Time`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledatetime)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowCoercion": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/DefWithParentheses": {
      "markdownDescription": "Checks for unnecessary parentheses in method definitions without parameters. For example, `def foo()` should be `def foo`. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledefwithparentheses)",
      "$ref": "#/definitions/cop"
    },
    "Style/DigChain": {
      "markdownDescription": "Checks for consecutive `dig` calls that can be combined into a single call. For example, `hash.dig(:a).dig(:b)` should be `hash.dig(:a, :b)`. More efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledigchain)",
      "$ref": "#/definitions/cop"
    },
    "Style/Dir": {
      "markdownDescription": "Checks for `File.expand_path` with `__dir__` and suggests using `__dir__` directly. For example, prefer `File.join(__dir__, 'foo')` over `File.expand_path('../foo', __FILE__)`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledir)",
      "$ref": "#/definitions/cop"
    },
    "Style/DirEmpty": {
      "markdownDescription": "Enforces use of `Dir.empty?` (Ruby 2.4+) instead of checking if `Dir.children` or `Dir.entries` is empty. More efficient and readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledirempty)",
      "$ref": "#/definitions/cop"
    },
    "Style/DisableCopsWithinSourceCodeDirective": {
      "markdownDescription": "Checks for inline RuboCop disable comments and can enforce department-level or cop-level disabling. Helps maintain control over which cops can be disabled. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledisablecopswithinsourcecodedirective)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedCops": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/DocumentDynamicEvalDefinition": {
      "markdownDescription": "Enforces adding a comment above methods defined dynamically with `define_method`, `class_eval`, etc. to document what method is being created. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledocumentdynamicevaldefinition)",
      "$ref": "#/definitions/cop"
    },
    "Style/Documentation": {
      "markdownDescription": "Checks for missing top-level documentation on classes and modules. Enforces that public classes/modules have explanatory comments. Improves maintainability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledocumentation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedConstants": {
              "$ref": "#/definitions/constants"
            }
          }
        }
      ]
    },
    "Style/DocumentationMethod": {
      "markdownDescription": "Checks for missing method documentation. Can require comments on all public methods or even private methods. Useful for library code and APIs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledocumentationmethod)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "RequireForNonPublicMethods": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/DoubleCopDisableDirective": {
      "markdownDescription": "Checks for duplicate RuboCop disable comments targeting the same cop. Redundant disables should be removed to keep configuration clean. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledoublecopdisabledirective)",
      "$ref": "#/definitions/cop"
    },
    "Style/DoubleNegation": {
      "markdownDescription": "Checks for double negation (`!!`) and suggests using explicit conversion methods or truthiness. Can allow double negation in return statements for boolean conversion. [Docs](https://docs.rubocop.org/rubocop/cops_style#styledoublenegation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["allowed_in_returns", "forbidden"],
              "markdownEnumDescriptions": [
                "Allow double negation in return statements for boolean coercion: `return !!value`",
                "Always disallow double negation, use explicit boolean conversion methods instead"
              ]
            }
          }
        }
      ]
    },
    "Style/EachForSimpleLoop": {
      "markdownDescription": "Checks for `each` being used for simple numeric loops and suggests using `Integer#times` instead. For example, prefer `3.times { }` over `(0..2).each { }`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleeachforsimpleloop)",
      "$ref": "#/definitions/cop"
    },
    "Style/EachWithObject": {
      "markdownDescription": "Checks for `inject`/`reduce` with an accumulator that's mutated and suggests using `each_with_object` instead. More idiomatic when building collections. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleeachwithobject)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyBlockParameter": {
      "markdownDescription": "Checks for blocks with empty parameter lists (`{ || }`) and suggests removing them. Unnecessary pipes should be omitted for clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptyblockparameter)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyCaseCondition": {
      "markdownDescription": "Checks for `case` statements without a condition and suggests converting to an `if/elsif/else` chain. More readable when there's no value being compared. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptycasecondition)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyClassDefinition": {
      "markdownDescription": "Enforces consistent style for empty class definitions. Choose between standard class definition or using `Class.new`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptyclassdefinition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["class_keyword", "class_new", "class_definition"],
              "markdownEnumDescriptions": [
                "Prefer class keyword syntax: `class Foo; end`",
                "Prefer Class.new syntax: `Foo = Class.new`",
                "Deprecated alias for `class_keyword`"
              ]
            },
            "AllowedParentClasses": {
              "$ref": "#/definitions/constants",
              "markdownDescription": "Parent classes for which both empty class styles are allowed regardless of `EnforcedStyle` (e.g., `StandardError`)."
            }
          }
        }
      ]
    },
    "Style/EmptyElse": {
      "markdownDescription": "Checks for empty `else` branches in conditionals. Can warn about or remove empty else blocks, or require explicit `nil`. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptyelse)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["empty", "nil", "both"],
              "markdownEnumDescriptions": [
                "Warn only about empty else branches",
                "Warn only about else branches with explicit nil",
                "Warn about both empty and nil else branches"
              ]
            },
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/EmptyHeredoc": {
      "markdownDescription": "Checks for empty heredocs and suggests using an empty string literal instead. Heredocs for empty strings are unnecessarily verbose. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptyheredoc)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyLambdaParameter": {
      "markdownDescription": "Checks for lambdas with empty parameter lists (`->() { }`) and suggests removing the parentheses. Unnecessary parentheses should be omitted. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptylambdaparameter)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyLiteral": {
      "markdownDescription": "Enforces use of literal syntax for empty collections. Prefer `[]` over `Array.new`, `{}` over `Hash.new`, and `''` over `String.new`. More concise and idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptyliteral)",
      "$ref": "#/definitions/cop"
    },
    "Style/EmptyMethod": {
      "markdownDescription": "Enforces consistent style for empty methods. Choose between compact (single line) or expanded (multi-line) format. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptymethod)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["compact", "expanded"],
              "markdownEnumDescriptions": [
                "Prefer compact single-line empty methods: `def foo; end`",
                "Prefer expanded multi-line empty methods: `def foo\\nend`"
              ]
            }
          }
        }
      ]
    },
    "Style/EmptyStringInsideInterpolation": {
      "markdownDescription": "Checks for empty strings inside string interpolation (`#{\"\"}`) and suggests removing them. Unnecessary interpolation should be cleaned up. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleemptystringinsideinterpolation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["trailing_conditional", "ternary"]
            }
          }
        }
      ]
    },
    "Style/Encoding": {
      "markdownDescription": "Checks for UTF-8 encoding comments (`# encoding: utf-8`). These are unnecessary in Ruby 2.0+ where UTF-8 is the default. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleencoding)",
      "$ref": "#/definitions/cop"
    },
    "Style/EndBlock": {
      "markdownDescription": "Checks for use of `END` blocks, which are rarely needed and can make code harder to understand. Avoid using them unless absolutely necessary. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleendblock)",
      "$ref": "#/definitions/cop"
    },
    "Style/EndlessMethod": {
      "markdownDescription": "Enforces or forbids use of Ruby 3.0+ endless method definitions (`def foo = bar`). Can require, allow, or disallow this syntax. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleendlessmethod)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "type": "string",
              "enum": [
                "allow_single_line",
                "allow_always",
                "disallow",
                "require_single_line",
                "require_always"
              ],
              "markdownEnumDescriptions": [
                "Allow endless method syntax only for single-line methods",
                "Allow endless method syntax for all methods",
                "Disallow endless method syntax entirely",
                "Require endless method syntax for single-line methods",
                "Require endless method syntax for all methods"
              ]
            }
          }
        }
      ]
    },
    "Style/EnvHome": {
      "markdownDescription": "Checks for `ENV['HOME']` and suggests using `Dir.home` instead. `Dir.home` is more portable and handles edge cases better. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleenvhome)",
      "$ref": "#/definitions/cop"
    },
    "Style/EvalWithLocation": {
      "markdownDescription": "Enforces passing file and line number to `eval`, `class_eval`, etc. for better backtraces. Improves debugging when dynamic code fails. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleevalwithlocation)",
      "$ref": "#/definitions/cop"
    },
    "Style/EvenOdd": {
      "markdownDescription": "Enforces use of `Integer#even?` and `Integer#odd?` instead of modulo operations. For example, prefer `x.even?` over `x % 2 == 0`. More readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleevenodd)",
      "$ref": "#/definitions/cop"
    },
    "Style/ExactRegexpMatch": {
      "markdownDescription": "Checks for regexes that match entire strings and suggests using `==` instead. For example, `/^foo$/` can be `== 'foo'`. More efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleexactregexpmatch)",
      "$ref": "#/definitions/cop"
    },
    "Style/ExpandPathArguments": {
      "markdownDescription": "Checks for `File.expand_path` with `__FILE__` in the second argument and suggests using `__dir__` instead. More concise and direct. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleexpandpatharguments)",
      "$ref": "#/definitions/cop"
    },
    "Style/ExplicitBlockArgument": {
      "markdownDescription": "Enforces explicit block parameters when yielding with arguments or calling `block.call`. Makes block usage more explicit and clear. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleexplicitblockargument)",
      "$ref": "#/definitions/cop"
    },
    "Style/ExponentialNotation": {
      "markdownDescription": "Enforces consistent style for exponential notation in numbers. Choose between scientific, engineering, or integral format. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleexponentialnotation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["scientific", "engineering", "integral"],
              "markdownEnumDescriptions": [
                "Use scientific notation: `1.23e4`",
                "Use engineering notation (exponents divisible by 3): `12.3e3`",
                "Use integral notation (no decimal point): `123e2`"
              ]
            }
          }
        }
      ]
    },
    "Style/FetchEnvVar": {
      "markdownDescription": "Enforces use of `ENV.fetch` instead of `ENV[]` for accessing environment variables. `fetch` makes missing variables explicit and allows default values. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefetchenvvar)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedVars": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "DefaultToNil": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/FileEmpty": {
      "markdownDescription": "Enforces use of `File.empty?` (Ruby 2.4+) instead of checking file size or reading content. More efficient and readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefileempty)",
      "$ref": "#/definitions/cop"
    },
    "Style/FileNull": {
      "markdownDescription": "Enforces use of `File::NULL` instead of hardcoded paths like `/dev/null`. More portable across operating systems. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefilenull)",
      "$ref": "#/definitions/cop"
    },
    "Style/FileOpen": {
      "markdownDescription": "Checks for `File.open` calls without a block, which can leak file descriptors. Encourages safer file handling patterns. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefileopen)",
      "$ref": "#/definitions/cop"
    },
    "Style/FileRead": {
      "markdownDescription": "Enforces use of `File.read` instead of `File.open` with a block that only reads. More concise for simple file reading operations. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefileread)",
      "$ref": "#/definitions/cop"
    },
    "Style/FileTouch": {
      "markdownDescription": "Enforces use of `FileUtils.touch` instead of manual file creation for creating empty files or updating timestamps. More explicit. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefiletouch)",
      "$ref": "#/definitions/cop"
    },
    "Style/FileWrite": {
      "markdownDescription": "Enforces use of `File.write` instead of `File.open` with 'w' mode and a block that only writes. More concise for simple write operations. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefilewrite)",
      "$ref": "#/definitions/cop"
    },
    "Style/FloatDivision": {
      "markdownDescription": "Enforces consistent style for float division to avoid integer division bugs. Can enforce converting one operand to float or using `fdiv`. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefloatdivision)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["left_coerce", "right_coerce", "single_coerce", "fdiv"],
              "markdownEnumDescriptions": [
                "Convert left operand to float: `a.to_f / b`",
                "Convert right operand to float: `a / b.to_f`",
                "Convert either operand to float (whichever is simpler)",
                "Use fdiv method for float division: `a.fdiv(b)`"
              ]
            }
          }
        }
      ]
    },
    "Style/For": {
      "markdownDescription": "Checks for `for` loops and suggests using `each` instead. The `for` keyword is rarely used in Ruby and `each` is more idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefor)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["each", "for"],
              "markdownEnumDescriptions": [
                "Prefer `each` for iteration: `array.each { |item| }`",
                "Prefer `for` loops for iteration: `for item in array`"
              ]
            }
          }
        }
      ]
    },
    "Style/FormatString": {
      "markdownDescription": "Enforces consistent use of string formatting methods. Choose between `format`/`sprintf` or string interpolation with `%` operator. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleformatstring)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["format", "sprintf", "percent"],
              "markdownEnumDescriptions": [
                "Prefer `format` method: `format('%d', 42)`",
                "Prefer `sprintf` method: `sprintf('%d', 42)`",
                "Prefer % operator: `'%d' % 42`"
              ]
            }
          }
        }
      ]
    },
    "Style/FormatStringToken": {
      "markdownDescription": "Enforces consistent style for format string tokens. Can require named placeholders (`%{name}`), templates (`%<name>s`), or allow unannotated (`%s`). [Docs](https://docs.rubocop.org/rubocop/cops_style#styleformatstringtoken)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["annotated", "template", "unannotated"],
              "markdownEnumDescriptions": [
                "Prefer annotated tokens: `format('%{name}', name: 'John')`",
                "Prefer template tokens: `format('%<name>s', name: 'John')`",
                "Allow unannotated tokens: `format('%s', 'John')`"
              ]
            },
            "MaxUnannotatedPlaceholdersAllowed": {
              "type": "integer",
              "minimum": 0
            },
            "Mode": {
              "enum": ["conservative", "aggressive"],
              "markdownEnumDescriptions": [
                "Only check format strings with multiple placeholders",
                "Check all format strings regardless of placeholder count"
              ]
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/FrozenStringLiteralComment": {
      "markdownDescription": "Enforces presence of `# frozen_string_literal: true` magic comment at the top of files. Helps improve performance by freezing string literals. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylefrozenstringliteralcomment)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["always", "always_true", "never"],
              "markdownEnumDescriptions": [
                "Always require frozen_string_literal comment (true or false)",
                "Always require frozen_string_literal: true specifically",
                "Never require frozen_string_literal comment"
              ]
            }
          }
        }
      ]
    },
    "Style/GlobalStdStream": {
      "markdownDescription": "Checks for global variables like `$stdout`, `$stderr`, `$stdin` and suggests using `STDOUT`, `STDERR`, `STDIN` constants instead. More explicit and testable. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleglobalstdstream)",
      "$ref": "#/definitions/cop"
    },
    "Style/GlobalVars": {
      "markdownDescription": "Checks for global variables (`$var`) and suggests avoiding them. Global variables make code harder to test and reason about. Use constants or dependency injection instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleglobalvars)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedVariables": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/GuardClause": {
      "markdownDescription": "Enforces use of guard clauses (early returns) instead of wrapping method body in conditionals. Reduces nesting and improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleguardclause)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinBodyLength": {
              "type": "integer",
              "minimum": 0
            },
            "AllowConsecutiveConditionals": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/HashAsLastArrayItem": {
      "markdownDescription": "Enforces consistent style for hashes as the last element in arrays. Can require or forbid braces around hash literals. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashaslastarrayitem)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["braces", "no_braces"]
            }
          }
        }
      ]
    },
    "Style/HashConversion": {
      "markdownDescription": "Checks for unnecessarily complex hash construction and suggests simpler alternatives. For example, `Hash[array.map { |x| [x, x] }]` can be `array.to_h { |x| [x, x] }`. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashconversion)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowSplatArgument": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/HashEachMethods": {
      "markdownDescription": "Enforces use of `each_key` and `each_value` instead of `each` when only using keys or values. More explicit and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehasheachmethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedReceivers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/HashExcept": {
      "markdownDescription": "Enforces use of `Hash#except` (Ruby 3.0+) instead of `reject` or `select` for removing keys. More readable and expressive. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashexcept)",
      "$ref": "#/definitions/cop"
    },
    "Style/HashFetchChain": {
      "markdownDescription": "Checks for chained `Hash#fetch` calls and suggests alternatives. Can suggest using `dig` with a fallback or nested fetch calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashfetchchain)",
      "$ref": "#/definitions/cop"
    },
    "Style/HashLikeCase": {
      "markdownDescription": "Checks for `case` statements that behave like hash lookups and suggests using an actual hash. More efficient for many branches. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashlikecase)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinBranchesCount": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/HashLookupMethod": {
      "markdownDescription": "Enforces consistent hash lookup style. Can prefer `[]` brackets or `fetch` for accessing hash values. `fetch` makes missing keys explicit. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashlookupmethod)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["brackets", "fetch"]
            },
            "AllowedReceivers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              },
              "markdownDescription": "Receiver expressions to ignore for this cop, such as `Rails.cache`."
            }
          }
        }
      ]
    },
    "Style/HashSlice": {
      "markdownDescription": "Enforces use of `Hash#slice` (Ruby 2.5+) instead of `select` when extracting specific keys. More readable and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashslice)",
      "$ref": "#/definitions/cop"
    },
    "Style/HashSyntax": {
      "markdownDescription": "Enforces consistent hash syntax. Can require modern Ruby 1.9+ syntax (`key: value`) or hash rockets (`=>`) or allow mixing based on key type. Very commonly customized. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashsyntax)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "ruby19",
                "hash_rockets",
                "no_mixed_keys",
                "ruby19_no_mixed_keys"
              ]
            },
            "EnforcedShorthandSyntax": {
              "enum": [
                "always",
                "never",
                "either",
                "consistent",
                "either_consistent"
              ]
            },
            "UseHashRocketsWithSymbolValues": {
              "type": "boolean"
            },
            "PreferHashRocketsForNonAlnumEndingSymbols": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/HashTransformKeys": {
      "markdownDescription": "Enforces use of `Hash#transform_keys` instead of `each_with_object` or `to_h` for transforming hash keys. More readable and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashtransformkeys)",
      "$ref": "#/definitions/cop"
    },
    "Style/HashTransformValues": {
      "markdownDescription": "Enforces use of `Hash#transform_values` instead of `each_with_object` or `to_h` for transforming hash values. More readable and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylehashtransformvalues)",
      "$ref": "#/definitions/cop"
    },
    "Style/IdenticalConditionalBranches": {
      "markdownDescription": "Checks for conditional branches with identical code and suggests extracting to avoid duplication. Reduces code complexity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleidenticalconditionalbranches)",
      "$ref": "#/definitions/cop"
    },
    "Style/IfInsideElse": {
      "markdownDescription": "Checks for `if` statements nested inside `else` blocks and suggests using `elsif` instead. Reduces nesting and improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleifinsideelse)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowIfModifier": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/IfUnlessModifier": {
      "markdownDescription": "Enforces use of modifier `if`/`unless` for single-line conditionals. For example, `return x if condition` instead of multi-line. Improves conciseness. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleifunlessmodifier)",
      "$ref": "#/definitions/cop"
    },
    "Style/IfUnlessModifierOfIfUnless": {
      "markdownDescription": "Checks for modifier `if`/`unless` applied to other `if`/`unless` statements and suggests refactoring. Helps avoid confusing nested conditionals. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleifunlessmodifierofifunless)",
      "$ref": "#/definitions/cop"
    },
    "Style/IfWithBooleanLiteralBranches": {
      "markdownDescription": "Checks for `if` statements that return boolean literals and suggests simplifying to the condition itself. For example, `if x then true else false` should be `x`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleifwithbooleanliteralbranches)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/IfWithSemicolon": {
      "markdownDescription": "Checks for semicolons in `if` statement bodies and suggests moving code to separate lines. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleifwithsemicolon)",
      "$ref": "#/definitions/cop"
    },
    "Style/ImplicitRuntimeError": {
      "markdownDescription": "Checks for `raise` without an exception class and suggests specifying `RuntimeError` explicitly. Makes error handling clearer. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleimplicitruntimeerror)",
      "$ref": "#/definitions/cop"
    },
    "Style/InPatternThen": {
      "markdownDescription": "Checks for unnecessary `then` keyword in `case/in` pattern matching branches. The keyword is optional and can be omitted. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleinpatternthen)",
      "$ref": "#/definitions/cop"
    },
    "Style/InfiniteLoop": {
      "markdownDescription": "Checks for explicit infinite loops (`while true`) and suggests using the `loop` keyword instead. More idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleinfiniteloop)",
      "$ref": "#/definitions/cop"
    },
    "Style/InlineComment": {
      "markdownDescription": "Checks for inline comments (comments on the same line as code) and suggests moving them above. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleinlinecomment)",
      "$ref": "#/definitions/cop"
    },
    "Style/InverseMethods": {
      "markdownDescription": "Checks for code that could be simplified using inverse methods. For example, `!x.include?(y)` should be `x.exclude?(y)`. More readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleinversemethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "InverseMethods": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            },
            "InverseBlocks": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/InvertibleUnlessCondition": {
      "markdownDescription": "Checks for `unless` conditions that could be inverted to use `if` instead. Helps maintain consistent conditional style throughout codebase. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleinvertibleunlesscondition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "InverseMethods": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/IpAddresses": {
      "markdownDescription": "Checks for hardcoded IP addresses in code and suggests extracting to constants or environment variables. Improves maintainability and security. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleipaddresses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedAddresses": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/ItAssignment": {
      "markdownDescription": "Checks for assignment to the special numbered parameter `_1` in block contexts. Prefer using explicit block parameters for clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleitassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/ItBlockParameter": {
      "markdownDescription": "Enforces or forbids use of the numbered parameter `it` in single-parameter blocks (Ruby 2.7+). Can require explicit parameters for clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleitblockparameter)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "allow_single_line",
                "only_numbered_parameters",
                "always",
                "disallow"
              ]
            }
          }
        }
      ]
    },
    "Style/KeywordArgumentsMerging": {
      "markdownDescription": "Enforces use of the double splat operator (`**`) for merging keyword arguments instead of `Hash.merge` or `Hash[**x]`. More idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylekeywordargumentsmerging)",
      "$ref": "#/definitions/cop"
    },
    "Style/KeywordParametersOrder": {
      "markdownDescription": "Enforces consistent ordering of keyword parameters in method definitions. Required keyword parameters should come before optional ones. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylekeywordparametersorder)",
      "$ref": "#/definitions/cop"
    },
    "Style/Lambda": {
      "markdownDescription": "Enforces consistent style for lambda definitions. Can require `lambda` keyword, literal syntax `->`, or decide based on line count. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylelambda)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["line_count_dependent", "lambda", "literal"]
            }
          }
        }
      ]
    },
    "Style/LambdaCall": {
      "markdownDescription": "Enforces consistent style for calling lambdas. Can require `call` method or allow the `[]` syntax. The `call` method is more explicit. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylelambdacall)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["call", "braces"]
            }
          }
        }
      ]
    },
    "Style/LineEndConcatenation": {
      "markdownDescription": "Checks for string concatenation at end of line (`+` at line end) and suggests using implicit concatenation or `<<` instead. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylelineendconcatenation)",
      "$ref": "#/definitions/cop"
    },
    "Style/MagicCommentFormat": {
      "markdownDescription": "Enforces consistent formatting for magic comments like `# frozen_string_literal: true`. Can enforce snake_case or kebab-case and capitalization. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemagiccommentformat)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["snake_case", "kebab_case"]
            },
            "DirectiveCapitalization": {
              "enum": [null, "lowercase", "uppercase"]
            },
            "ValueCapitalization": {
              "enum": [null, "lowercase", "uppercase"]
            }
          }
        }
      ]
    },
    "Style/MapCompactWithConditionalBlock": {
      "markdownDescription": "Checks for `map { if condition then value end }` and suggests using `filter_map` (Ruby 2.7+) instead. More readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemapcompactwithconditionalblock)",
      "$ref": "#/definitions/cop"
    },
    "Style/MapIntoArray": {
      "markdownDescription": "Checks for `map.to_a` which is redundant since `map` already returns an array. Suggests just using `map`. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemapintoarray)",
      "$ref": "#/definitions/cop"
    },
    "Style/MapJoin": {
      "markdownDescription": "Checks for redundant `map(&:to_s)` before `join` and suggests simplifying to `join` directly when possible. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemapjoin)",
      "$ref": "#/definitions/cop"
    },
    "Style/MapToHash": {
      "markdownDescription": "Checks for `map { [k, v] }.to_h` and suggests using `to_h { |x| [k, v] }` instead. More concise. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemaptohash)",
      "$ref": "#/definitions/cop"
    },
    "Style/MapToSet": {
      "markdownDescription": "Checks for `map { value }.to_set` and suggests using `to_set { value }` instead. More concise and idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemaptoset)",
      "$ref": "#/definitions/cop"
    },
    "Style/MethodCallWithArgsParentheses": {
      "markdownDescription": "Enforces consistent use of parentheses in method calls with arguments. Can require them always or omit them when possible. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemethodcallwithargsparentheses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IgnoreMacros": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "IncludedMacros": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "IncludedMacroPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowParenthesesInMultilineCall": {
              "type": "boolean"
            },
            "AllowParenthesesInChaining": {
              "type": "boolean"
            },
            "AllowParenthesesInCamelCaseMethod": {
              "type": "boolean"
            },
            "AllowParenthesesInStringInterpolation": {
              "type": "boolean"
            },
            "EnforcedStyle": {
              "enum": ["require_parentheses", "omit_parentheses"]
            }
          }
        }
      ]
    },
    "Style/MethodCallWithoutArgsParentheses": {
      "markdownDescription": "Enforces omitting parentheses for method calls without arguments. For example, prefer `foo` over `foo()`. More idiomatic. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemethodcallwithoutargsparentheses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/MethodCalledOnDoEndBlock": {
      "markdownDescription": "Checks for methods called on blocks using `do...end` and suggests using `{...}` instead. Method chaining works better with braces. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemethodcalledondoendblock)",
      "$ref": "#/definitions/cop"
    },
    "Style/MethodDefParentheses": {
      "markdownDescription": "Enforces consistent use of parentheses in method definitions. Can require them always, never, or only in multi-line methods. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemethoddefparentheses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "require_parentheses",
                "require_no_parentheses",
                "require_no_parentheses_except_multiline"
              ]
            }
          }
        }
      ]
    },
    "Style/MinMax": {
      "markdownDescription": "Checks for `[a, b].min` and `[a, b].max` and suggests using `[a, b].minmax` instead. More efficient when you need both values. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleminmax)",
      "$ref": "#/definitions/cop"
    },
    "Style/MinMaxComparison": {
      "markdownDescription": "Checks for manual min/max comparisons and suggests using `clamp`. For example, prefer `value.clamp(min, max)` over conditional logic. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleminmaxcomparison)",
      "$ref": "#/definitions/cop"
    },
    "Style/MissingElse": {
      "markdownDescription": "Checks for `if`/`case` statements without corresponding `else` branches and optionally requires them. Helps ensure all branches are handled. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemissingelse)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["if", "case", "both"]
            }
          }
        }
      ]
    },
    "Style/MissingRespondToMissing": {
      "markdownDescription": "Checks for `method_missing` implementations without corresponding `respond_to_missing?` method. Both should be defined together. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemissingrespondtomissing)",
      "$ref": "#/definitions/cop"
    },
    "Style/MixinGrouping": {
      "markdownDescription": "Enforces consistent style for multiple `include`/`extend` statements. Can require grouping multiple mixins or separating them. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemixingrouping)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["separated", "grouped"]
            }
          }
        }
      ]
    },
    "Style/MixinUsage": {
      "markdownDescription": "Checks that `include` and `extend` are used at the top level of classes/modules. Using them inside methods or outside class context is incorrect. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemixinusage)",
      "$ref": "#/definitions/cop"
    },
    "Style/ModuleFunction": {
      "markdownDescription": "Enforces consistent style for defining module methods. Can prefer `module_function`, `extend_self`, or forbid all usage. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemodulefunction)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["module_function", "extend_self", "forbidden"]
            }
          }
        }
      ]
    },
    "Style/ModuleMemberExistenceCheck": {
      "markdownDescription": "Checks for module member existence checks using `respond_to?` or `const_defined?` and suggests using predicate methods instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemodulememberexistencecheck)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/MultilineBlockChain": {
      "markdownDescription": "Checks for chaining methods on multi-line blocks and suggests breaking into multiple statements for readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilineblockchain)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineIfModifier": {
      "markdownDescription": "Checks for modifier `if` statements that span multiple lines and suggests converting to normal `if` block. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilineifmodifier)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineIfThen": {
      "markdownDescription": "Checks for unnecessary `then` keyword in multi-line `if` statements. The keyword is optional and can be omitted. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilineifthen)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineInPatternThen": {
      "markdownDescription": "Checks for unnecessary `then` keyword in multi-line `case/in` pattern matching. The keyword is optional. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilineinpatternthen)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineMemoization": {
      "markdownDescription": "Enforces consistent style for memoization pattern in multi-line conditions. Can use the `||=` operator or conditional braces. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilinememoization)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["keyword", "braces"]
            }
          }
        }
      ]
    },
    "Style/MultilineMethodSignature": {
      "markdownDescription": "Checks that method definitions with multiple parameters don't have the opening parenthesis on a separate line. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilinemethodsignature)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineTernaryOperator": {
      "markdownDescription": "Checks for ternary operators (`? :`) that span multiple lines and suggests converting to `if/else` blocks. More readable for multi-line conditionals. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilineternaryoperator)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultilineWhenThen": {
      "markdownDescription": "Checks for unnecessary `then` keyword in multi-line `case/when` statements. The keyword is optional. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultilinewhenthen)",
      "$ref": "#/definitions/cop"
    },
    "Style/MultipleComparison": {
      "markdownDescription": "Checks for repeated comparisons to the same variable and suggests using `Array#include?` or `Range#cover?` instead. More readable and efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemultiplecomparison)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMethodComparison": {
              "type": "boolean"
            },
            "ComparisonsThreshold": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/MutableConstant": {
      "markdownDescription": "Checks for mutable objects assigned to constants (arrays, hashes, strings) which can be inadvertently modified. Suggests freezing them. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylemutableconstant)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["literals", "strict"]
            }
          }
        }
      ]
    },
    "Style/NegatedIf": {
      "markdownDescription": "Enforces consistent style for negated conditionals. Can require negation at beginning (`unless`), end (modifier `unless`), or both. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenegatedif)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["both", "prefix", "postfix"]
            }
          }
        }
      ]
    },
    "Style/NegatedIfElseCondition": {
      "markdownDescription": "Checks for `if !condition then A else B` and suggests swapping branches or using `unless`. Reduces double negatives. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenegatedifelsecondition)",
      "$ref": "#/definitions/cop"
    },
    "Style/NegatedUnless": {
      "markdownDescription": "Enforces consistent style for double negatives in `unless` statements. Can require negation at beginning, end, or both. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenegatedunless)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["both", "prefix", "postfix"]
            }
          }
        }
      ]
    },
    "Style/NegatedWhile": {
      "markdownDescription": "Checks for `while !condition` and suggests using `until condition` instead. More readable. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenegatedwhile)",
      "$ref": "#/definitions/cop"
    },
    "Style/NegativeArrayIndex": {
      "markdownDescription": "Checks for negative array indexing (`[-1]`) and suggests using positive indices instead. Can help with consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenegativearrayindex)",
      "$ref": "#/definitions/cop"
    },
    "Style/NestedFileDirname": {
      "markdownDescription": "Checks for `File.dirname(File.dirname(...))` and suggests using `File.dirname` with the result. More efficient. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenestedfiledirname)",
      "$ref": "#/definitions/cop"
    },
    "Style/NestedModifier": {
      "markdownDescription": "Checks for nested modifier `if`/`unless` statements and suggests converting to normal conditionals. Reduces nesting. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenestedmodifier)",
      "$ref": "#/definitions/cop"
    },
    "Style/NestedParenthesizedCalls": {
      "markdownDescription": "Checks for unnecessary parentheses in nested method calls and suggests removing them when possible. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenestedparenthesizedcalls)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/NestedTernaryOperator": {
      "markdownDescription": "Checks for nested ternary operators and suggests converting to `if/else` blocks. Ternaries are hard to read when nested. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenestedternaryoperator)",
      "$ref": "#/definitions/cop"
    },
    "Style/Next": {
      "markdownDescription": "Enforces use of `next` in loops instead of wrapping body in conditionals. Reduces nesting and improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenext)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["skip_modifier_ifs", "always"]
            },
            "MinBodyLength": {
              "type": "integer",
              "minimum": 0
            },
            "AllowConsecutiveConditionals": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/NilComparison": {
      "markdownDescription": "Enforces checking for nil using predicate methods (`nil?`) instead of direct comparisons. Improves code readability and follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenilcomparison)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["predicate", "comparison"]
            }
          }
        }
      ]
    },
    "Style/NilLambda": {
      "markdownDescription": "Enforces using `-> { }` (lambda literal) instead of `Proc.new { }` for single-line nil returning procs. Improves code clarity and consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenillambda)",
      "$ref": "#/definitions/cop"
    },
    "Style/NonNilCheck": {
      "markdownDescription": "Enforces checking for non-nil values using positive conditions rather than double negation. Improves code readability and logic clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenonnilcheck)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "IncludeSemanticChanges": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/Not": {
      "markdownDescription": "Enforces using `!` for logical negation instead of the `not` keyword. Improves consistency and is more idiomatic Ruby. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenot)",
      "$ref": "#/definitions/cop"
    },
    "Style/NumberedParameters": {
      "markdownDescription": "Enforces consistent use of numbered parameters in blocks (e.g., `_1`, `_2`). Improves clarity over implicit positional arguments. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenumberedparameters)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["allow_single_line", "disallow"]
            }
          }
        }
      ]
    },
    "Style/NumberedParametersLimit": {
      "markdownDescription": "Enforces a maximum number of numbered parameters allowed in a block. Improves readability by limiting complex numbered parameter usage. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenumberedparameterslimit)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/NumericLiteralPrefix": {
      "markdownDescription": "Enforces consistent prefixes for numeric literals (e.g., `0o` for octal instead of `0`). Improves code clarity and prevents confusion. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenumericliteralprefix)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedOctalStyle": {
              "enum": ["zero_with_o", "zero_only"]
            }
          }
        }
      ]
    },
    "Style/NumericLiterals": {
      "markdownDescription": "Enforces use of underscores in large numeric literals for readability (e.g., `1_000_000` instead of `1000000`). Improves visual parsing of large numbers. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenumericliterals)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "MinDigits": {
              "type": "integer",
              "minimum": 0
            },
            "Strict": {
              "type": "boolean"
            },
            "AllowedNumbers": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/NumericPredicate": {
      "markdownDescription": "Enforces using predicate methods (e.g., `zero?`, `positive?`) instead of numeric comparisons. Improves code readability and idiomaticity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylenumericpredicate)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["predicate", "comparison"]
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/ObjectThen": {
      "markdownDescription": "Enforces consistent use of `then` method for chaining or `yield_self` alternative. Improves code consistency in functional-style chaining. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleobjectthen)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["then", "yield_self"]
            }
          }
        }
      ]
    },
    "Style/OneClassPerFile": {
      "markdownDescription": "Checks that each source file defines at most one top-level class or module. Encourages clearer file organization. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleoneclassperfile)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedClasses": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/OneLineConditional": {
      "markdownDescription": "Enforces multi-line formatting for complex ternary expressions to improve readability. Reduces cognitive load on single-line conditionals. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleonelineconditional)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AlwaysCorrectToMultiline": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/OpenStructUse": {
      "markdownDescription": "Discourages use of OpenStruct in favor of proper classes or hashes. Improves code clarity and avoids potential runtime issues. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleopenstructuse)",
      "$ref": "#/definitions/cop"
    },
    "Style/OperatorMethodCall": {
      "markdownDescription": "Enforces using operator syntax instead of explicit method calls for operators. Improves code readability and follows Ruby conventions. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleoperatormethodcall)",
      "$ref": "#/definitions/cop"
    },
    "Style/OptionHash": {
      "markdownDescription": "Discourages using hash arguments as options when they should be keyword arguments instead. Improves method signature clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleoptionhash)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "SuspiciousParamNames": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "Allowlist": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/OptionalArguments": {
      "markdownDescription": "Enforces placing optional parameters after required parameters in method definitions. Improves method signature clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleoptionalarguments)",
      "$ref": "#/definitions/cop"
    },
    "Style/OptionalBooleanParameter": {
      "markdownDescription": "Discourages boolean parameters in method definitions as they often indicate methods doing too much. Use separate methods instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleoptionalbooleanparameter)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/OrAssignment": {
      "markdownDescription": "Enforces using `||=` operator for assignment when initializing variables with default values. Improves conciseness and clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleorassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/ParallelAssignment": {
      "markdownDescription": "Discourages parallel assignment of multiple variables to reduce potential for confusion and errors. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleparallelassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/ParenthesesAroundCondition": {
      "markdownDescription": "Enforces consistent use of parentheses around conditions in if/unless statements. Improves code consistency and readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleparenthesesaroundcondition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowSafeAssignment": {
              "type": "boolean"
            },
            "AllowInMultilineConditions": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/PartitionInsteadOfDoubleSelect": {
      "markdownDescription": "Checks for consecutive `select`/`filter` and `reject` calls on the same receiver with matching predicates, and suggests using `partition` instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylepartitioninsteadofdoubleselect)",
      "$ref": "#/definitions/cop"
    },
    "Style/PercentLiteralDelimiters": {
      "markdownDescription": "Enforces consistent delimiters for percent literals (e.g., `%w[a b c]` vs `%w(a b c)`). Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylepercentliteraldelimiters)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "PreferredDelimiters": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/PercentQLiterals": {
      "markdownDescription": "Enforces consistent case for `%q` and `%Q` percent literals. Improves code consistency and readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylepercentqliterals)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["lower_case_q", "upper_case_q"]
            }
          }
        }
      ]
    },
    "Style/PerlBackrefs": {
      "markdownDescription": "Discourages use of Perl-style backreferences like `$1`, `$2` in regex matches. Use Ruby's match data instead for clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleperlbackrefs)",
      "$ref": "#/definitions/cop"
    },
    "Style/PredicateWithKind": {
      "markdownDescription": "Checks for block predicates like `any? { |x| x.is_a?(Klass) }` and suggests shorthand forms like `any?(Klass)` when available. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylepredicatewithkind)",
      "$ref": "#/definitions/cop"
    },
    "Style/PreferredHashMethods": {
      "markdownDescription": "Enforces consistent hash access methods (`fetch` vs `[]`, `dig` vs `[]`). Improves consistency and prevents nil-related bugs. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylepreferredhashmethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["short", "verbose"]
            }
          }
        }
      ]
    },
    "Style/Proc": {
      "markdownDescription": "Enforces using `Proc.new` instead of `proc` for creating Proc objects. Improves code clarity and consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleproc)",
      "$ref": "#/definitions/cop"
    },
    "Style/QuotedSymbols": {
      "markdownDescription": "Enforces consistent quoting style for symbols matching string literal conventions. Improves code consistency and readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylequotedsymbols)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "same_as_string_literals",
                "single_quotes",
                "double_quotes"
              ]
            }
          }
        }
      ]
    },
    "Style/RaiseArgs": {
      "markdownDescription": "Enforces consistent style for raising exceptions with or without explicit arguments. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleraiseargs)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["compact", "exploded"]
            },
            "AllowedCompactTypes": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/RandomWithOffset": {
      "markdownDescription": "Enforces avoiding Random.rand() with offsets; use Random.randrange() instead. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylerandomwithoffset)",
      "$ref": "#/definitions/cop"
    },
    "Style/ReduceToHash": {
      "markdownDescription": "Checks for hash-building patterns with `each_with_object`, `inject`, or `reduce` and suggests using `to_h { ... }` when possible. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylereducetohash)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantArgument": {
      "markdownDescription": "Detects arguments that are not needed since they duplicate default values. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantargument)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Methods": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/RedundantArrayConstructor": {
      "markdownDescription": "Detects redundant Array() calls that can be simplified. Reduces unnecessary method calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantarrayconstructor)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantArrayFlatten": {
      "markdownDescription": "Detects unnecessary flatten calls that can be removed. Improves performance. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantarrayflatten)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantAssignment": {
      "markdownDescription": "Detects unnecessary variable assignments that duplicate existing values. Removes redundant code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantBegin": {
      "markdownDescription": "Detects unnecessary begin/end blocks that can be removed. Simplifies code structure. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantbegin)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantCapitalW": {
      "markdownDescription": "Detects redundant capital W in %W word arrays that don't use interpolation. Suggests using %w instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantcapitalw)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantCondition": {
      "markdownDescription": "Detects conditions that are always true or false based on context. Removes redundant logic. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantcondition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/RedundantConditional": {
      "markdownDescription": "Detects unnecessary ternary operators that can be simplified. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantconditional)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantConstantBase": {
      "markdownDescription": "Detects redundant class scope operators like ::ClassName. Simplifies constant access. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantconstantbase)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantCurrentDirectoryInPath": {
      "markdownDescription": "Detects unnecessary ./ in file paths. Simplifies path specifications. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantcurrentdirectoryinpath)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantDoubleSplatHashBraces": {
      "markdownDescription": "Detects unnecessary double splat operator with braces in kwargs. Simplifies syntax. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantdoublesplathashbraces)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantEach": {
      "markdownDescription": "Detects each blocks that don't use the block parameter. Suggests removing or using a different iterator. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundanteach)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantException": {
      "markdownDescription": "Detects raise statements with redundant exception class. Simplifies exception raising. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantexception)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantFetchBlock": {
      "markdownDescription": "Detects redundant fetch blocks that don't perform necessary computation. Removes unnecessary code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantfetchblock)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "SafeForConstants": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/RedundantFileExtensionInRequire": {
      "markdownDescription": "Detects require statements with unnecessary file extensions. Simplifies require calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantfileextensioninrequire)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantFilterChain": {
      "markdownDescription": "Detects multiple filter/select/reject calls that can be combined. Improves efficiency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantfilterchain)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantFormat": {
      "markdownDescription": "Detects redundant calls to String#% when String#format would be clearer. Improves consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantformat)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantFreeze": {
      "markdownDescription": "Detects unnecessary freeze calls on already-frozen objects. Removes redundant method calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantfreeze)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantHeredocDelimiterQuotes": {
      "markdownDescription": "Detects unnecessary quotes in heredoc delimiters. Simplifies heredoc syntax. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantheredocdelimiterquotes)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantInitialize": {
      "markdownDescription": "Detects initialize methods that only call super without changes. Removes unnecessary methods. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantinitialize)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/RedundantInterpolation": {
      "markdownDescription": "Detects unnecessary string interpolation when concatenation would work. Simplifies strings. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantinterpolation)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantInterpolationUnfreeze": {
      "markdownDescription": "Detects unnecessary string duplication to unfreeze frozen strings. Suggests better alternatives. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantinterpolationunfreeze)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantLineContinuation": {
      "markdownDescription": "Detects unnecessary line continuation characters. Simplifies code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantlinecontinuation)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantMinMaxBy": {
      "markdownDescription": "Checks for cases where `max_by`/`min_by` can be replaced with simpler `max`/`min` calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantminmaxby)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantParentheses": {
      "markdownDescription": "Detects unnecessary parentheses around expressions. Reduces visual clutter. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantparentheses)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantPercentQ": {
      "markdownDescription": "Detects %q with no interpolation that can use regular strings. Simplifies quote usage. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantpercentq)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantRegexpArgument": {
      "markdownDescription": "Detects methods like scan, match with redundant regexp arguments. Simplifies code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantregexpargument)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantRegexpCharacterClass": {
      "markdownDescription": "Detects unnecessary character classes like [a] that should be 'a'. Simplifies regexps. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantregexpcharacterclass)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantRegexpConstructor": {
      "markdownDescription": "Detects redundant Regexp.new calls that can use literals. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantregexpconstructor)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantRegexpEscape": {
      "markdownDescription": "Detects unnecessary escape sequences in regexps. Simplifies regular expressions. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantregexpescape)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantReturn": {
      "markdownDescription": "Detects unnecessary return statements in methods that implicitly return. Reduces code verbosity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantreturn)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMultipleReturnValues": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/RedundantSelf": {
      "markdownDescription": "Detects unnecessary explicit self references when not needed. Simplifies code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantself)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantSelfAssignment": {
      "markdownDescription": "Detects redundant self-assignment operations. Removes unnecessary operations. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantselfassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantSelfAssignmentBranch": {
      "markdownDescription": "Detects self-assignments in conditional branches. Suggests simplification. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantselfassignmentbranch)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantSort": {
      "markdownDescription": "Detects unnecessary sort followed by other operations. Improves efficiency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantsort)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantSortBy": {
      "markdownDescription": "Detects sort_by blocks that don't transform values. Suggests using sort instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantsortby)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantStringEscape": {
      "markdownDescription": "Detects unnecessary escape sequences in strings. Simplifies string literals. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantstringescape)",
      "$ref": "#/definitions/cop"
    },
    "Style/RedundantStructKeywordInit": {
      "markdownDescription": "Checks for redundant `keyword_init` options in `Struct.new` calls. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleredundantstructkeywordinit)",
      "$ref": "#/definitions/cop"
    },
    "Style/RegexpLiteral": {
      "markdownDescription": "Enforces consistent style for regexp literals using slashes or %r{}. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleregexpliteral)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["slashes", "percent_r", "mixed"]
            },
            "AllowInnerSlashes": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/RequireOrder": {
      "markdownDescription": "Enforces a consistent order for require statements. Improves code organization. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylerequireorder)",
      "$ref": "#/definitions/cop"
    },
    "Style/RescueModifier": {
      "markdownDescription": "Discourages inline rescue modifiers for better error handling visibility. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylerescuemodifier)",
      "$ref": "#/definitions/cop"
    },
    "Style/RescueStandardError": {
      "markdownDescription": "Enforces explicit StandardError rescue instead of bare rescue. Improves exception handling clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylerescuestandarderror)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["implicit", "explicit"]
            }
          }
        }
      ]
    },
    "Style/ReturnNil": {
      "markdownDescription": "Enforces consistent style for returning nil explicitly vs implicitly. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylereturnnil)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["return", "return_nil"]
            }
          }
        }
      ]
    },
    "Style/ReturnNilInPredicateMethodDefinition": {
      "markdownDescription": "Enforces proper return nil in predicate method definition handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylereturnnilinpredicatemethoddefinition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/ReverseFind": {
      "markdownDescription": "Enforces proper reverse find handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylereversefind)",
      "$ref": "#/definitions/cop"
    },
    "Style/SafeNavigation": {
      "markdownDescription": "Enforces proper safe navigation handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesafenavigation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ConvertCodeThatCanStartToReturnNil": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "MaxChainLength": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/SafeNavigationChainLength": {
      "markdownDescription": "Enforces proper safe navigation chain length handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesafenavigationchainlength)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Max": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/Sample": {
      "markdownDescription": "Enforces proper sample handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesample)",
      "$ref": "#/definitions/cop"
    },
    "Style/SelectByKind": {
      "markdownDescription": "Checks for `select`/`reject`/`find` patterns with kind checks and suggests `grep`/`grep_v` alternatives when appropriate. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleselectbykind)",
      "$ref": "#/definitions/cop"
    },
    "Style/SelectByRange": {
      "markdownDescription": "Checks for `select`/`reject`/`find` patterns with range checks and suggests `grep`/`grep_v` alternatives when appropriate. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleselectbyrange)",
      "$ref": "#/definitions/cop"
    },
    "Style/SelectByRegexp": {
      "markdownDescription": "Enforces proper select by regexp handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleselectbyregexp)",
      "$ref": "#/definitions/cop"
    },
    "Style/SelfAssignment": {
      "markdownDescription": "Enforces proper self assignment handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleselfassignment)",
      "$ref": "#/definitions/cop"
    },
    "Style/Semicolon": {
      "markdownDescription": "Enforces proper semicolon handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesemicolon)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowAsExpressionSeparator": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/Send": {
      "markdownDescription": "Enforces proper send handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesend)",
      "$ref": "#/definitions/cop"
    },
    "Style/SendWithLiteralMethodName": {
      "markdownDescription": "Enforces proper send with literal method name handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesendwithliteralmethodname)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowSend": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/SignalException": {
      "markdownDescription": "Enforces proper signal exception handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesignalexception)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["only_raise", "only_fail", "semantic"]
            }
          }
        }
      ]
    },
    "Style/SingleArgumentDig": {
      "markdownDescription": "Enforces proper single argument dig handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesingleargumentdig)",
      "$ref": "#/definitions/cop"
    },
    "Style/SingleLineBlockParams": {
      "markdownDescription": "Enforces proper single line block params handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesinglelineblockparams)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Methods": {
              "type": "object",
              "additionalProperties": {
                "type": "array",
                "uniqueItems": true,
                "items": {
                  "type": "string"
                }
              }
            }
          }
        }
      ]
    },
    "Style/SingleLineDoEndBlock": {
      "markdownDescription": "Enforces proper single line do end block handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesinglelinedoendblock)",
      "$ref": "#/definitions/cop"
    },
    "Style/SingleLineMethods": {
      "markdownDescription": "Enforces proper single line methods handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesinglelinemethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowIfMethodIsEmpty": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/SlicingWithRange": {
      "markdownDescription": "Enforces proper slicing with range handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleslicingwithrange)",
      "$ref": "#/definitions/cop"
    },
    "Style/SoleNestedConditional": {
      "markdownDescription": "Enforces proper sole nested conditional handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesolenestedconditional)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowModifier": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/SpecialGlobalVars": {
      "markdownDescription": "Enforces proper special global vars handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylespecialglobalvars)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "RequireEnglish": {
              "type": "boolean"
            },
            "EnforcedStyle": {
              "enum": [
                "use_perl_names",
                "use_english_names",
                "use_builtin_english_names"
              ]
            }
          }
        }
      ]
    },
    "Style/StabbyLambdaParentheses": {
      "markdownDescription": "Enforces proper stabby lambda parentheses handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestabbylambdaparentheses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["require_parentheses", "require_no_parentheses"]
            }
          }
        }
      ]
    },
    "Style/StaticClass": {
      "markdownDescription": "Enforces proper static class handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestaticclass)",
      "$ref": "#/definitions/cop"
    },
    "Style/StderrPuts": {
      "markdownDescription": "Enforces proper stderr puts handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestderrputs)",
      "$ref": "#/definitions/cop"
    },
    "Style/StringChars": {
      "markdownDescription": "Enforces proper string chars handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringchars)",
      "$ref": "#/definitions/cop"
    },
    "Style/StringConcatenation": {
      "markdownDescription": "Enforces proper string concatenation handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringconcatenation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "Mode": {
              "enum": ["aggressive", "conservative"]
            }
          }
        }
      ]
    },
    "Style/StringHashKeys": {
      "markdownDescription": "Enforces proper string hash keys handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringhashkeys)",
      "$ref": "#/definitions/cop"
    },
    "Style/StringLiterals": {
      "markdownDescription": "Enforces proper string literals handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringliterals)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["single_quotes", "double_quotes"]
            },
            "ConsistentQuotesInMultiline": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/StringLiteralsInInterpolation": {
      "markdownDescription": "Enforces proper string literals in interpolation handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringliteralsininterpolation)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["single_quotes", "double_quotes"]
            }
          }
        }
      ]
    },
    "Style/StringMethods": {
      "markdownDescription": "Enforces proper string methods handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestringmethods)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "PreferredMethods": {
              "type": "object",
              "additionalProperties": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/Strip": {
      "markdownDescription": "Enforces proper strip handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestrip)",
      "$ref": "#/definitions/cop"
    },
    "Style/StructInheritance": {
      "markdownDescription": "Enforces proper struct inheritance handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylestructinheritance)",
      "$ref": "#/definitions/cop"
    },
    "Style/SuperArguments": {
      "markdownDescription": "Enforces proper super arguments handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesuperarguments)",
      "$ref": "#/definitions/cop"
    },
    "Style/SuperWithArgsParentheses": {
      "markdownDescription": "Enforces proper super with args parentheses handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesuperwithargsparentheses)",
      "$ref": "#/definitions/cop"
    },
    "Style/SwapValues": {
      "markdownDescription": "Enforces proper swap values handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleswapvalues)",
      "$ref": "#/definitions/cop"
    },
    "Style/SymbolArray": {
      "markdownDescription": "Enforces proper symbol array handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesymbolarray)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["percent", "brackets"]
            },
            "MinSize": {
              "type": "integer",
              "minimum": 0
            }
          }
        }
      ]
    },
    "Style/SymbolLiteral": {
      "markdownDescription": "Enforces proper symbol literal handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesymbolliteral)",
      "$ref": "#/definitions/cop"
    },
    "Style/SymbolProc": {
      "markdownDescription": "Enforces proper symbol proc handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylesymbolproc)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowMethodsWithArguments": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowedPatterns": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            },
            "AllowComments": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/TallyMethod": {
      "markdownDescription": "Checks for manual counting patterns that can be replaced with `Enumerable#tally`. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletallymethod)",
      "$ref": "#/definitions/cop"
    },
    "Style/TernaryParentheses": {
      "markdownDescription": "Enforces proper ternary parentheses handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleternaryparentheses)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "require_parentheses",
                "require_no_parentheses",
                "require_parentheses_when_complex"
              ]
            },
            "AllowSafeAssignment": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/TopLevelMethodDefinition": {
      "markdownDescription": "Enforces proper top level method definition handling. Improves code quality. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletoplevelmethoddefinition)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingBodyOnClass": {
      "markdownDescription": "Enforces handling of trailing trailing body on class. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingbodyonclass)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingBodyOnMethodDefinition": {
      "markdownDescription": "Enforces handling of trailing trailing body on method definition. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingbodyonmethoddefinition)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingBodyOnModule": {
      "markdownDescription": "Enforces formatting for single-line module definitions. Improves code style. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingbodyonmodule)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingCommaInArguments": {
      "markdownDescription": "Enforces trailing commas in multi-line arguments. Improves diffs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingcommainarguments)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleForMultiline": {
              "enum": ["comma", "consistent_comma", "diff_comma", "no_comma"]
            }
          }
        }
      ]
    },
    "Style/TrailingCommaInArrayLiteral": {
      "markdownDescription": "Enforces trailing commas in multi-line arrays. Improves diffs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingcommainarrayliteral)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleForMultiline": {
              "enum": ["comma", "consistent_comma", "diff_comma", "no_comma"]
            }
          }
        }
      ]
    },
    "Style/TrailingCommaInBlockArgs": {
      "markdownDescription": "Enforces trailing commas in block arguments. Improves consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingcommainblockargs)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingCommaInHashLiteral": {
      "markdownDescription": "Enforces trailing commas in multi-line hashes. Improves diffs. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingcommainhashliteral)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyleForMultiline": {
              "enum": ["comma", "consistent_comma", "diff_comma", "no_comma"]
            }
          }
        }
      ]
    },
    "Style/TrailingMethodEndStatement": {
      "markdownDescription": "Enforces method body on same line as end. Improves code formatting. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingmethodendstatement)",
      "$ref": "#/definitions/cop"
    },
    "Style/TrailingUnderscoreVariable": {
      "markdownDescription": "Detects trailing underscore in variables. Suggests removing or using properly. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrailingunderscorevariable)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "AllowNamedUnderscoreVariables": {
              "type": "boolean"
            }
          }
        }
      ]
    },
    "Style/TrivialAccessors": {
      "markdownDescription": "Detects trivial accessor methods that could be replaced. Suggests attr_reader/writer. [Docs](https://docs.rubocop.org/rubocop/cops_style#styletrivialaccessors)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "ExactNameMatch": {
              "type": "boolean"
            },
            "AllowPredicates": {
              "type": "boolean"
            },
            "AllowDSLWriters": {
              "type": "boolean"
            },
            "IgnoreClassMethods": {
              "type": "boolean"
            },
            "AllowedMethods": {
              "type": "array",
              "uniqueItems": true,
              "items": {
                "type": "string"
              }
            }
          }
        }
      ]
    },
    "Style/UnlessElse": {
      "markdownDescription": "Enforces unless without else instead of if-else. Improves code clarity. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleunlesselse)",
      "$ref": "#/definitions/cop"
    },
    "Style/UnlessLogicalOperators": {
      "markdownDescription": "Detects logical operators in unless conditions. Suggests using if instead. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleunlesslogicaloperators)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "forbid_mixed_logical_operators",
                "forbid_logical_operators"
              ]
            }
          }
        }
      ]
    },
    "Style/UnpackFirst": {
      "markdownDescription": "Detects multiple assignments that should use first. Suggests using first method. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleunpackfirst)",
      "$ref": "#/definitions/cop"
    },
    "Style/VariableInterpolation": {
      "markdownDescription": "Detects unnecessary interpolation in strings. Suggests simpler syntax. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylevariableinterpolation)",
      "$ref": "#/definitions/cop"
    },
    "Style/WhenThen": {
      "markdownDescription": "Enforces then keyword usage in when clauses. Improves consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylewhenthen)",
      "$ref": "#/definitions/cop"
    },
    "Style/WhileUntilDo": {
      "markdownDescription": "Enforces removal of do keyword after while/until. Improves code consistency. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylewhileuntildo)",
      "$ref": "#/definitions/cop"
    },
    "Style/WhileUntilModifier": {
      "markdownDescription": "Enforces modifier style for while/until. Improves readability. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylewhileuntilmodifier)",
      "$ref": "#/definitions/cop"
    },
    "Style/WordArray": {
      "markdownDescription": "Enforces %w usage for word arrays. Improves code conciseness. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylewordarray)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": ["percent", "brackets"]
            },
            "MinSize": {
              "type": "integer",
              "minimum": 0
            },
            "WordRegex": {
              "type": "string"
            }
          }
        }
      ]
    },
    "Style/YAMLFileRead": {
      "markdownDescription": "Detects manual YAML file reading that should use YAML.load_file. Simplifies code. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleyamlfileread)",
      "$ref": "#/definitions/cop"
    },
    "Style/YodaCondition": {
      "markdownDescription": "Detects 'yoda conditions' with literal on left side. Suggests normal order. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleyodacondition)",
      "allOf": [
        {
          "$ref": "#/definitions/cop"
        },
        {
          "properties": {
            "EnforcedStyle": {
              "enum": [
                "forbid_for_all_comparison_operators",
                "forbid_for_equality_operators_only",
                "require_for_all_comparison_operators",
                "require_for_equality_operators_only"
              ]
            }
          }
        }
      ]
    },
    "Style/YodaExpression": {
      "markdownDescription": "Detects 'yoda expressions' with literal on left side. Suggests normal order. [Docs](https://docs.rubocop.org/rubocop/cops_style#styleyodaexpression)",
      "$ref": "#/definitions/cop"
    },
    "Style/ZeroLengthPredicate": {
      "markdownDescription": "Enforces using empty? instead of length == 0. Improves code idiomaticity. [Docs](https://docs.rubocop.org/rubocop/cops_style#stylezerolengthpredicate)",
      "$ref": "#/definitions/cop"
    }
  },
  "additionalProperties": {
    "anyOf": [
      {
        "$ref": "#/definitions/cop"
      },
      {
        "$ref": "#/definitions/department"
      }
    ]
  }
}