//!
//! THIS FILE IS GENERATED USING CODE - DO NOT EDIT MANUALLY
//!

pub mod action_validator;
pub mod actionlint;
pub mod air_format;
pub mod alejandra;
pub mod alex;
pub mod ameba;
pub mod ansible_lint;
pub mod api_linter;
pub mod asmfmt;
pub mod astyle;
pub mod atlas_fmt;
pub mod atlas_lint;
pub mod auto_optional;
pub mod autocorrect;
pub mod autoflake;
pub mod autopep_8;
pub mod bashate;
pub mod beancount_black;
pub mod beautysh;
pub mod bibtex_tidy;
pub mod bicep_format;
pub mod biome_check;
pub mod biome_check_unsafe;
pub mod biome_format;
pub mod biome_lint;
pub mod biome_lint_unsafe;
pub mod black;
pub mod blade_formatter;
pub mod blue;
pub mod bpfmt;
pub mod brittany;
pub mod brunette;
pub mod bsfmt;
pub mod bslint;
pub mod buf_format;
pub mod buf_lint;
pub mod buildifier;
pub mod cabal_fmt;
pub mod cabal_format;
pub mod cabal_gild;
pub mod cabal_prettify;
pub mod caddy_fmt;
pub mod caramel_fmt;
pub mod cedar_format;
pub mod cfn_lint;
pub mod checkmake;
pub mod clang_format;
pub mod clang_tidy;
pub mod clj_kondo;
pub mod cljfmt_fix;
pub mod cljstyle;
pub mod cmake_format;
pub mod cmake_lint;
pub mod codeql_query_format;
pub mod codespell;
pub mod coffeelint;
pub mod cppcheck;
pub mod cpplint;
pub mod crlfmt;
pub mod crystal_format;
pub mod csharpier;
pub mod css_beautify;
pub mod csscomb;
pub mod csslint;
pub mod cue_fmt;
pub mod cueimports;
pub mod curlylint;
pub mod d_2_fmt;
pub mod dart_fix;
pub mod dart_format;
pub mod dcm_fix;
pub mod dcm_format;
pub mod deadnix;
pub mod deno_fmt;
pub mod deno_lint;
pub mod dfmt;
pub mod dhall_format;
pub mod dhall_lint;
pub mod djade;
pub mod djlint;
pub mod docformatter;
pub mod dockerfmt;
pub mod dockfmt;
pub mod docstrfmt;
pub mod doctoc;
pub mod dotenv_linter_fix;
pub mod dprint_fmt;
pub mod dscanner_fix;
pub mod dscanner_lint;
pub mod dune_format_dune_file;
pub mod duster_fix;
pub mod duster_lint;
pub mod dx_fmt;
pub mod easy_coding_standard;
pub mod efmt;
pub mod elm_format;
pub mod eradicate;
pub mod erb_formatter;
pub mod erg_lint;
pub mod erlfmt;
pub mod eslint;
pub mod fantomas;
pub mod fish_indent;
pub mod fixjson;
pub mod floskell;
pub mod flynt;
pub mod fnlfmt;
pub mod forge_fmt;
pub mod fortitude_check;
pub mod fortitude_check_fix;
pub mod fortitude_check_fix_unsafe;
pub mod fortran_linter;
pub mod fourmolu;
pub mod fprettify;
pub mod futhark_fmt;
pub mod fvm_dart_fix;
pub mod fvm_dart_format;
pub mod gci;
pub mod gdformat;
pub mod gdlint;
pub mod gersemi;
pub mod ghokin_check;
pub mod ghokin_fmt;
pub mod gleam_format;
pub mod gluon_fmt;
pub mod gofmt;
pub mod gofumpt;
pub mod goimports;
pub mod goimports_reviser;
pub mod golangci_lint_fmt;
pub mod golangci_lint_run;
pub mod golangci_lint_run_fix;
pub mod golines;
pub mod google_java_format;
pub mod gospel;
pub mod grafbase_lint;
pub mod grain_format;
pub mod hadolint;
pub mod haml_lint;
pub mod hclfmt;
pub mod hfmt;
pub mod hindent;
pub mod hlint;
pub mod html_beautify;
pub mod htmlbeautifier;
pub mod htmlhint;
pub mod hurlfmt;
pub mod imba_fmt;
pub mod inko_fmt;
pub mod isort;
pub mod janet_format;
pub mod joker;
pub mod jq;
pub mod jqfmt;
pub mod js_beautify;
pub mod json_5_format;
pub mod json_repair;
pub mod jsona_format;
pub mod jsona_lint;
pub mod jsonlint;
pub mod jsonlint_sort;
pub mod jsonnet_lint;
pub mod jsonnetfmt;
pub mod jsonpp;
pub mod juliaformatter_jl;
pub mod just;
pub mod kcl_fmt;
pub mod kcl_lint;
pub mod kdlfmt;
pub mod kdlfmt_v_1;
pub mod kdlfmt_v_2;
pub mod kdoc_formatter;
pub mod keep_sorted;
pub mod ktfmt;
pub mod ktlint;
pub mod kube_linter_lint;
pub mod kulala_fmt_check;
pub mod kulala_fmt_format;
pub mod leptosfmt;
pub mod liquidsoap_prettier;
pub mod luacheck;
pub mod luaformatter;
pub mod luau_analyze;
pub mod mado_check;
pub mod mago_analyze;
pub mod mago_analyze_fix;
pub mod mago_analyze_fix_unsafe;
pub mod mago_format;
pub mod mago_lint;
pub mod mago_lint_fix;
pub mod mago_lint_fix_unsafe;
pub mod markdownfmt;
pub mod markdownlint;
pub mod markdownlint_cli_2;
pub mod markuplint;
pub mod mbake_format;
pub mod mbake_validate;
pub mod md_padding;
pub mod mdformat;
pub mod mdsf_format;
pub mod mdsf_verify;
pub mod mdslw;
pub mod meson_fmt;
pub mod mh_lint;
pub mod mh_style;
pub mod mise_fmt;
pub mod misspell;
pub mod mix_format;
pub mod mojo_format;
pub mod muon_fmt;
pub mod muon_lint;
pub mod mypy;
pub mod nasmfmt;
pub mod nginxbeautifier;
pub mod nginxfmt;
pub mod nickel_format;
pub mod nimpretty;
pub mod nixfmt;
pub mod nixpkgs_fmt;
pub mod nomad_fmt;
pub mod nph;
pub mod npm_groovy_lint;
pub mod nufmt;
pub mod ocamlformat;
pub mod ocp_indent;
pub mod odinfmt;
pub mod oelint_adv;
pub mod opa_fmt;
pub mod ormolu;
pub mod oxfmt;
pub mod oxlint;
pub mod packer_fix;
pub mod packer_fmt;
pub mod packer_validate;
pub mod pasfmt;
pub mod perflint;
pub mod perltidy;
pub mod pg_format;
pub mod php_cs_fixer_fix;
pub mod phpcbf;
pub mod phpinsights_fix;
pub mod pint;
pub mod pkl_format;
pub mod prettier;
pub mod prettierd;
pub mod pretty_php;
pub mod prettypst;
pub mod prisma_format;
pub mod proselint;
pub mod protolint;
pub mod ptop;
pub mod pug_lint;
pub mod puppet_lint;
pub mod purs_tidy;
pub mod purty;
pub mod pycln;
pub mod pycodestyle;
pub mod pydoclint;
pub mod pydocstringformatter;
pub mod pydocstyle;
pub mod pyflakes;
pub mod pyink;
pub mod pylint;
pub mod pymarkdownlnt_fix;
pub mod pyment;
pub mod pyrefly;
pub mod pyupgrade;
pub mod qmlfmt;
pub mod qmlformat;
pub mod qmllint;
pub mod quick_lint_js;
pub mod raco_fmt;
pub mod reek;
pub mod refmt;
pub mod reformat_gherkin;
pub mod refurb;
pub mod regal_fix;
pub mod regal_lint;
pub mod reorder_python_imports;
pub mod rescript_format;
pub mod revive;
pub mod roc_format;
pub mod rstfmt;
pub mod rubocop;
pub mod rubyfmt;
pub mod ruff_check;
pub mod ruff_format;
pub mod rufo;
pub mod rumdl_check;
pub mod rumdl_check_fix;
pub mod rumdl_fmt;
pub mod rune_fmt;
pub mod runic;
pub mod rustfmt;
pub mod rustfmt_2015;
pub mod rustfmt_2018;
pub mod rustfmt_2021;
pub mod rustfmt_2024;
pub mod rustywind;
pub mod salt_lint;
pub mod scala;
pub mod scalafmt;
pub mod scalariform;
pub mod selene;
pub mod semistandard;
pub mod shellcheck;
pub mod shellharden;
pub mod shfmt;
pub mod sleek;
pub mod slim_lint;
pub mod smlfmt;
pub mod snakefmt;
pub mod solhint;
pub mod sphinx_lint;
pub mod sql_formatter;
pub mod sqlfluff_fix;
pub mod sqlfluff_format;
pub mod sqlfluff_lint;
pub mod sqlfmt;
pub mod sqlint;
pub mod sqruff;
pub mod squawk;
pub mod standardjs;
pub mod standardrb;
pub mod statix_check;
pub mod statix_fix;
pub mod stylefmt;
pub mod stylelint;
pub mod stylish_haskell;
pub mod stylua;
pub mod superhtml_fmt;
pub mod svlint;
pub mod swift_format;
pub mod swiftformat;
pub mod swiftlint;
pub mod taplo;
pub mod tclfmt;
pub mod tclint;
pub mod templ_fmt;
pub mod terraform_fmt;
pub mod terragrunt_hclfmt;
pub mod tex_fmt;
pub mod textlint;
pub mod textlint_fix;
pub mod tlint_format;
pub mod tofu_fmt;
pub mod tombi_format;
pub mod tombi_lint;
pub mod toml_sort;
pub mod topiary;
pub mod tryceratops;
pub mod ts_standard;
pub mod tsp_format;
pub mod tsqllint;
pub mod twig_cs_fixer_check;
pub mod twig_cs_fixer_fix;
pub mod twig_cs_fixer_lint;
pub mod twigcs;
pub mod txtpbfmt;
pub mod ty;
pub mod typos;
pub mod typstfmt;
pub mod typstyle;
pub mod ufmt;
pub mod uiua_fmt;
pub mod unimport;
pub mod usort;
pub mod v_fmt;
pub mod vacuum_lint;
pub mod verusfmt;
pub mod veryl_fmt;
pub mod vhdl_style_guide;
pub mod vint;
pub mod vint_neovim;
pub mod wa_fmt;
pub mod wfindent;
pub mod write_good;
pub mod xmlformat;
pub mod xmllint;
pub mod xo;
pub mod xq;
pub mod xq_html;
pub mod yamlfix;
pub mod yamlfmt;
pub mod yamllint;
pub mod yapf;
pub mod yard_lint;
pub mod yew_fmt;
pub mod yq;
pub mod zig_fmt;
pub mod ziggy_check;
pub mod ziggy_fmt;
pub mod zprint;
pub mod zsweep;
pub mod zuban;
pub mod zuban_check;
pub mod zuban_mypy;

#[derive(serde::Serialize, serde::Deserialize, Hash, Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
pub enum Tooling {
    #[serde(rename = "action-validator")]
    /// Tool to validate GitHub Action and Workflow YAML files
    ///
    /// [https://github.com/mpalmer/action-validator](https://github.com/mpalmer/action-validator)
    ///
    /// `action-validator $PATH`
    ActionValidator,

    #[serde(rename = "actionlint")]
    /// Static checker for GitHub Actions workflow files
    ///
    /// [https://github.com/rhysd/actionlint](https://github.com/rhysd/actionlint)
    ///
    /// `actionlint $PATH`
    Actionlint,

    #[serde(rename = "air:format")]
    /// A code formatter for R
    ///
    /// [https://posit-dev.github.io/air/formatter.html](https://posit-dev.github.io/air/formatter.html)
    ///
    /// `air format $PATH`
    AirFormat,

    #[serde(rename = "alejandra")]
    /// The Uncompromising Nix Code Formatter
    ///
    /// [https://github.com/kamadorueda/alejandra](https://github.com/kamadorueda/alejandra)
    ///
    /// `alejandra --quiet $PATH`
    Alejandra,

    #[serde(rename = "alex")]
    /// Catch insensitive, inconsiderate writing
    ///
    /// [https://github.com/get-alex/alex](https://github.com/get-alex/alex)
    ///
    /// `alex --quiet $PATH`
    Alex,

    #[serde(rename = "ameba")]
    /// A static code analysis tool for Crystal
    ///
    /// [https://github.com/crystal-ameba/ameba](https://github.com/crystal-ameba/ameba)
    ///
    /// `ameba --fix $PATH`
    Ameba,

    #[serde(rename = "ansible-lint")]
    /// ansible-lint checks playbooks for practices and behavior that could potentially be improved and can fix some of the most common ones for you
    ///
    /// [https://github.com/ansible/ansible-lint](https://github.com/ansible/ansible-lint)
    ///
    /// `ansible-lint $PATH`
    AnsibleLint,

    #[serde(rename = "api-linter")]
    /// A linter for APIs defined in protocol buffers
    ///
    /// [https://github.com/googleapis/api-linter](https://github.com/googleapis/api-linter)
    ///
    /// `api-linter $PATH`
    ApiLinter,

    #[serde(rename = "asmfmt")]
    /// Go Assembler Formatter
    ///
    /// [https://github.com/klauspost/asmfmt](https://github.com/klauspost/asmfmt)
    ///
    /// `asmfmt -w $PATH`
    Asmfmt,

    #[serde(rename = "astyle")]
    /// A Free, Fast, and Small Automatic Formatter for C, C++, C++/CLI, Objective-C, C#, and Java Source Code
    ///
    /// [https://gitlab.com/saalen/astyle](https://gitlab.com/saalen/astyle)
    ///
    /// `astyle --quiet $PATH`
    Astyle,

    #[serde(rename = "atlas:fmt")]
    /// Formats Atlas HCL files
    ///
    /// [https://atlasgo.io/cli-reference#atlas-schema-fmt](https://atlasgo.io/cli-reference#atlas-schema-fmt)
    ///
    /// `atlas schema fmt $PATH`
    AtlasFmt,

    #[serde(rename = "atlas:lint")]
    /// Lints Atlas HCL files
    ///
    /// [https://atlasgo.io/cli-reference#atlas-migrate-lint](https://atlasgo.io/cli-reference#atlas-migrate-lint)
    ///
    /// `atlas schema lint $PATH`
    AtlasLint,

    #[serde(rename = "auto-optional")]
    /// Makes typed arguments Optional when the default argument is None
    ///
    /// [https://github.com/luttik/auto-optional](https://github.com/luttik/auto-optional)
    ///
    /// `auto-optional $PATH`
    AutoOptional,

    #[serde(rename = "autocorrect")]
    /// A linter and formatter to help you to improve copywriting, correct spaces, words, and punctuations between CJK (Chinese, Japanese, Korean)
    ///
    /// [https://github.com/huacnlee/autocorrect](https://github.com/huacnlee/autocorrect)
    ///
    /// `autocorrect --fix $PATH`
    Autocorrect,

    #[serde(rename = "autoflake")]
    /// Removes unused imports and unused variables as reported by pyflakes
    ///
    /// [https://github.com/pycqa/autoflake](https://github.com/pycqa/autoflake)
    ///
    /// `autoflake --quiet --in-place $PATH`
    Autoflake,

    #[serde(rename = "autopep8")]
    /// A tool that automatically formats Python code to conform to the PEP 8 style guide
    ///
    /// [https://github.com/hhatto/autopep8](https://github.com/hhatto/autopep8)
    ///
    /// `autopep8 --in-place $PATH`
    Autopep8,

    #[serde(rename = "bashate")]
    /// Code style enforcement for bash programs
    ///
    /// [https://github.com/openstack/bashate](https://github.com/openstack/bashate)
    ///
    /// `bashate $PATH`
    Bashate,

    #[serde(rename = "beancount-black")]
    /// Opinionated code formatter, just like Python's black code formatter but for Beancount
    ///
    /// [https://github.com/launchplatform/beancount-black](https://github.com/launchplatform/beancount-black)
    ///
    /// `bean-black $PATH`
    BeancountBlack,

    #[serde(rename = "beautysh")]
    /// A Bash beautifier for the masses
    ///
    /// [https://github.com/lovesegfault/beautysh](https://github.com/lovesegfault/beautysh)
    ///
    /// `beautysh $PATH`
    Beautysh,

    #[serde(rename = "bibtex-tidy")]
    /// Cleaner and Formatter for BibTeX files
    ///
    /// [https://github.com/flamingtempura/bibtex-tidy](https://github.com/flamingtempura/bibtex-tidy)
    ///
    /// `bibtex-tidy -m $PATH`
    BibtexTidy,

    #[serde(rename = "bicep:format")]
    /// Bicep is a declarative language for describing and deploying Azure resources
    ///
    /// [https://github.com/azure/bicep](https://github.com/azure/bicep)
    ///
    /// `bicep format $PATH`
    BicepFormat,

    #[serde(rename = "biome:check")]
    /// Runs biome formatter, linter and import sorting with unsafe fixes on the input
    ///
    /// [https://biomejs.dev/reference/cli/#biome-check](https://biomejs.dev/reference/cli/#biome-check)
    ///
    /// `biome check --write $PATH`
    BiomeCheck,

    #[serde(rename = "biome:check:unsafe")]
    /// Runs biome formatter, linter and import sorting on the input
    ///
    /// [https://biomejs.dev/reference/cli/#biome-check](https://biomejs.dev/reference/cli/#biome-check)
    ///
    /// `biome check --write --unsafe $PATH`
    BiomeCheckUnsafe,

    #[serde(rename = "biome:format")]
    /// Runs the biome formatter on input
    ///
    /// [https://biomejs.dev/reference/cli/#biome-format](https://biomejs.dev/reference/cli/#biome-format)
    ///
    /// `biome format --write $PATH`
    BiomeFormat,

    #[serde(rename = "biome:lint")]
    /// Runs the biome linter on input
    ///
    /// [https://biomejs.dev/reference/cli/#biome-lint](https://biomejs.dev/reference/cli/#biome-lint)
    ///
    /// `biome lint --write $PATH`
    BiomeLint,

    #[serde(rename = "biome:lint:unsafe")]
    /// Runs the biome linter with unsafe fixes enable
    ///
    /// [https://biomejs.dev/reference/cli/#biome-format](https://biomejs.dev/reference/cli/#biome-format)
    ///
    /// `biome lint --write --unsafe $PATH`
    BiomeLintUnsafe,

    #[serde(rename = "black")]
    /// The uncompromising Python code formatter
    ///
    /// [https://github.com/psf/black](https://github.com/psf/black)
    ///
    /// `black --quiet $PATH`
    Black,

    #[serde(rename = "blade-formatter")]
    /// An opinionated blade template formatter for Laravel that respects readability
    ///
    /// [https://github.com/shufo/blade-formatter](https://github.com/shufo/blade-formatter)
    ///
    /// `blade-formatter --write $PATH`
    BladeFormatter,

    #[serde(rename = "blue")]
    /// The slightly less uncompromising Python code formatter
    ///
    /// [https://github.com/grantjenks/blue](https://github.com/grantjenks/blue)
    ///
    /// `blue --quiet $PATH`
    Blue,

    #[serde(rename = "bpfmt")]
    /// A formatter for Blueprint files
    ///
    /// [https://source.android.com/docs/setup/reference/androidbp#formatter](https://source.android.com/docs/setup/reference/androidbp#formatter)
    ///
    /// `bpfmt -w $PATH`
    Bpfmt,

    #[serde(rename = "brittany")]
    /// Haskell source code formatter
    ///
    /// [https://github.com/lspitzner/brittany](https://github.com/lspitzner/brittany)
    ///
    /// `brittany --write-mode=inplace $PATH`
    Brittany,

    #[serde(rename = "brunette")]
    /// A best practice Python code formatter
    ///
    /// [https://pypi.org/project/brunette](https://pypi.org/project/brunette)
    ///
    /// `brunette --quiet $PATH`
    Brunette,

    #[serde(rename = "bsfmt")]
    /// A code formatter for BrighterScript (and BrightScript)
    ///
    /// [https://github.com/rokucommunity/brighterscript-formatter](https://github.com/rokucommunity/brighterscript-formatter)
    ///
    /// `bsfmt $PATH --write`
    Bsfmt,

    #[serde(rename = "bslint")]
    /// A linter for BrightScript and BrighterScript
    ///
    /// [https://github.com/rokucommunity/bslint](https://github.com/rokucommunity/bslint)
    ///
    /// `bslint --fix $PATH`
    Bslint,

    #[serde(rename = "buf:format")]
    /// Format Protobuf files
    ///
    /// [https://buf.build/docs/format/style](https://buf.build/docs/format/style)
    ///
    /// `buf format --write $PATH`
    BufFormat,

    #[serde(rename = "buf:lint")]
    /// Lint Protobuf files
    ///
    /// [https://buf.build/docs/lint/overview](https://buf.build/docs/lint/overview)
    ///
    /// `buf lint $PATH`
    BufLint,

    #[serde(rename = "buildifier")]
    /// A bazel BUILD file formatter and editor
    ///
    /// [https://github.com/bazelbuild/buildtools](https://github.com/bazelbuild/buildtools)
    ///
    /// `buildifier $PATH`
    Buildifier,

    #[serde(rename = "cabal-fmt")]
    /// An experiment of formatting .cabal files
    ///
    /// [https://github.com/phadej/cabal-fmt](https://github.com/phadej/cabal-fmt)
    ///
    /// `cabal-fmt --inplace $PATH`
    CabalFmt,

    #[serde(rename = "cabal-gild")]
    /// Format Haskell package descriptions
    ///
    /// [https://github.com/tfausak/cabal-gild](https://github.com/tfausak/cabal-gild)
    ///
    /// `cabal-gild --input $PATH --output $PATH`
    CabalGild,

    #[serde(rename = "cabal-prettify")]
    /// Prettify your Cabal package configuration files
    ///
    /// [https://github.com/kindaro/cabal-prettify](https://github.com/kindaro/cabal-prettify)
    ///
    /// `cabal-prettify $PATH`
    CabalPrettify,

    #[serde(rename = "cabal:format")]
    /// Reformat the .cabal file using the standard style
    ///
    /// [https://www.haskell.org/cabal](https://www.haskell.org/cabal)
    ///
    /// `cabal format $PATH`
    CabalFormat,

    #[serde(rename = "caddy:fmt")]
    /// Formats or prettifies a Caddyfile
    ///
    /// [https://caddyserver.com/docs/command-line#caddy-fmt](https://caddyserver.com/docs/command-line#caddy-fmt)
    ///
    /// `caddy fmt $PATH -w`
    CaddyFmt,

    #[serde(rename = "caramel:fmt")]
    /// Format Caramel code
    ///
    /// [https://caramel.run](https://caramel.run)
    ///
    /// `caramel fmt $PATH`
    CaramelFmt,

    #[serde(rename = "cedar:format")]
    /// Format a cedar policy set
    ///
    /// [https://github.com/cedar-policy/cedar](https://github.com/cedar-policy/cedar)
    ///
    /// `cedar format`
    CedarFormat,

    #[serde(rename = "cfn-lint")]
    /// CloudFormation Linter
    ///
    /// [https://github.com/aws-cloudformation/cfn-lint](https://github.com/aws-cloudformation/cfn-lint)
    ///
    /// `cfn-lint $PATH`
    CfnLint,

    #[serde(rename = "checkmake")]
    /// Linter/analyzer for Makefiles
    ///
    /// [https://github.com/mrtazz/checkmake](https://github.com/mrtazz/checkmake)
    ///
    /// `checkmake $PATH`
    Checkmake,

    #[serde(rename = "clang-format")]
    /// A tool to format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# code
    ///
    /// [https://clang.llvm.org/docs/ClangFormat.html](https://clang.llvm.org/docs/ClangFormat.html)
    ///
    /// `clang-format -i $PATH`
    ClangFormat,

    #[serde(rename = "clang-tidy")]
    /// clang-tidy is a clang-based C++ “linter” tool
    ///
    /// [https://clang.llvm.org/extra/clang-tidy](https://clang.llvm.org/extra/clang-tidy)
    ///
    /// `clang-tidy --fix $PATH`
    ClangTidy,

    #[serde(rename = "clj-kondo")]
    /// Static analyzer and linter for Clojure code that sparks joy
    ///
    /// [https://github.com/clj-kondo/clj-kondo](https://github.com/clj-kondo/clj-kondo)
    ///
    /// `clj-kondo --lint $PATH`
    CljKondo,

    #[serde(rename = "cljfmt:fix")]
    /// A tool for formatting Clojure code
    ///
    /// [https://github.com/weavejester/cljfmt](https://github.com/weavejester/cljfmt)
    ///
    /// `cljfmt fix $PATH`
    CljfmtFix,

    #[serde(rename = "cljstyle")]
    /// A tool for formatting Clojure code
    ///
    /// [https://github.com/greglook/cljstyle](https://github.com/greglook/cljstyle)
    ///
    /// `cljstyle fix $PATH`
    Cljstyle,

    #[serde(rename = "cmake-format")]
    /// cmake-format can format your listfiles nicely so that they don't look like crap
    ///
    /// [https://cmake-format.readthedocs.io/en/latest/cmake-format.html](https://cmake-format.readthedocs.io/en/latest/cmake-format.html)
    ///
    /// `cmake-format -i $PATH`
    CmakeFormat,

    #[serde(rename = "cmake-lint")]
    /// Lint CMake files
    ///
    /// [https://cmake-format.readthedocs.io/en/latest/lint-usage.html](https://cmake-format.readthedocs.io/en/latest/lint-usage.html)
    ///
    /// `cmake-lint $PATH`
    CmakeLint,

    #[serde(rename = "codeql:query:format")]
    /// Format queries and libraries with CodeQL
    ///
    /// [https://docs.github.com/en/code-security/codeql-cli/codeql-cli-manual/query-format](https://docs.github.com/en/code-security/codeql-cli/codeql-cli-manual/query-format)
    ///
    /// `codeql query format -i $PATH`
    CodeqlQueryFormat,

    #[serde(rename = "codespell")]
    /// Check code for common misspellings
    ///
    /// [https://github.com/codespell-project/codespell](https://github.com/codespell-project/codespell)
    ///
    /// `codespell $PATH --check-hidden --write-changes`
    Codespell,

    #[serde(rename = "coffeelint")]
    /// Lint your CoffeeScript
    ///
    /// [https://github.com/coffeelint/coffeelint](https://github.com/coffeelint/coffeelint)
    ///
    /// `coffeelint -q $PATH`
    Coffeelint,

    #[serde(rename = "cppcheck")]
    /// Cppcheck is a static analysis tool for C/C++ code
    ///
    /// [https://cppcheck.sourceforge.io](https://cppcheck.sourceforge.io)
    ///
    /// `cppcheck $PATH`
    Cppcheck,

    #[serde(rename = "cpplint")]
    /// Static code checker for C++
    ///
    /// [https://github.com/cpplint/cpplint](https://github.com/cpplint/cpplint)
    ///
    /// `cpplint --quiet $PATH`
    Cpplint,

    #[serde(rename = "crlfmt")]
    /// Formatter for CockroachDB's additions to the Go style guide
    ///
    /// [https://github.com/cockroachdb/crlfmt](https://github.com/cockroachdb/crlfmt)
    ///
    /// `crlfmt -w $PATH`
    Crlfmt,

    #[serde(rename = "crystal:format")]
    /// Formats Crystal code
    ///
    /// [https://crystal-lang.org/reference/1.15/man/crystal/index.html#crystal-tool-format](https://crystal-lang.org/reference/1.15/man/crystal/index.html#crystal-tool-format)
    ///
    /// `crystal tool format $PATH`
    CrystalFormat,

    #[serde(rename = "csharpier")]
    /// CSharpier is an opinionated code formatter for C#
    ///
    /// [https://github.com/belav/csharpier](https://github.com/belav/csharpier)
    ///
    /// `csharpier format --write-stdout`
    Csharpier,

    #[serde(rename = "css-beautify")]
    /// A CSS formatter
    ///
    /// [https://github.com/beautifier/js-beautify](https://github.com/beautifier/js-beautify)
    ///
    /// `css-beautify -r --type css -f $PATH`
    CssBeautify,

    #[serde(rename = "csscomb")]
    /// CSS coding style formatter
    ///
    /// [https://github.com/csscomb/csscomb.js](https://github.com/csscomb/csscomb.js)
    ///
    /// `csscomb -t $PATH`
    Csscomb,

    #[serde(rename = "csslint")]
    /// Automated linting of Cascading Stylesheets
    ///
    /// [https://github.com/csslint/csslint](https://github.com/csslint/csslint)
    ///
    /// `csslint --quiet $PATH`
    Csslint,

    #[serde(rename = "cue:fmt")]
    /// Format CUE files
    ///
    /// [https://cuelang.org/docs/reference/command/cue-help-fmt](https://cuelang.org/docs/reference/command/cue-help-fmt)
    ///
    /// `cue fmt $PATH`
    CueFmt,

    #[serde(rename = "cueimports")]
    /// CUE tool that updates your import lines, adding missing ones and removing unused ones
    ///
    /// [https://github.com/asdine/cueimports](https://github.com/asdine/cueimports)
    ///
    /// `cueimports`
    Cueimports,

    #[serde(rename = "curlylint")]
    /// Experimental HTML templates linting for Jinja, Nunjucks, Django templates, Twig, Liquid
    ///
    /// [https://github.com/thibaudcolas/curlylint](https://github.com/thibaudcolas/curlylint)
    ///
    /// `curlylint -q $PATH`
    Curlylint,

    #[serde(rename = "d2:fmt")]
    /// Format d2 code
    ///
    /// [https://d2lang.com](https://d2lang.com)
    ///
    /// `d2 fmt $PATH`
    D2Fmt,

    #[serde(rename = "dart:fix")]
    /// Fixes errors in dart code
    ///
    /// [https://dart.dev/tools/dart-fix](https://dart.dev/tools/dart-fix)
    ///
    /// `dart fix --apply $PATH`
    DartFix,

    #[serde(rename = "dart:format")]
    /// Formats dart code
    ///
    /// [https://dart.dev/tools/dart-format](https://dart.dev/tools/dart-format)
    ///
    /// `dart format $PATH`
    DartFormat,

    #[serde(rename = "dcm:fix")]
    /// Fixes issues produced by dcm analyze, dcm check-unused-code, dcm check-unused-files or dcm check-dependencies commands
    ///
    /// [https://dcm.dev/docs/cli/formatting/fix](https://dcm.dev/docs/cli/formatting/fix)
    ///
    /// `dcm fix $PATH`
    DcmFix,

    #[serde(rename = "dcm:format")]
    /// Formats dart files
    ///
    /// [https://dcm.dev/docs/cli/formatting/format](https://dcm.dev/docs/cli/formatting/format)
    ///
    /// `dcm format $PATH`
    DcmFormat,

    #[serde(rename = "deadnix")]
    /// Scan Nix files for dead code
    ///
    /// [https://github.com/astro/deadnix](https://github.com/astro/deadnix)
    ///
    /// `deadnix -q --edit $PATH`
    Deadnix,

    #[serde(rename = "deno:fmt")]
    /// Formatter and linter for JavaScript and TypeScript
    ///
    /// [https://docs.deno.com/runtime/reference/cli/fmt](https://docs.deno.com/runtime/reference/cli/fmt)
    ///
    /// `deno fmt --quiet $PATH`
    DenoFmt,

    #[serde(rename = "deno:lint")]
    /// Formatter and linter for JavaScript and TypeScript
    ///
    /// [https://docs.deno.com/runtime/reference/cli/lint](https://docs.deno.com/runtime/reference/cli/lint)
    ///
    /// `deno lint --fix $PATH`
    DenoLint,

    #[serde(rename = "dfmt")]
    /// Dfmt is a formatter for D source code
    ///
    /// [https://github.com/dlang-community/dfmt](https://github.com/dlang-community/dfmt)
    ///
    /// `dfmt -i $PATH`
    Dfmt,

    #[serde(rename = "dhall:format")]
    /// Format Dhall files
    ///
    /// [https://dhall-lang.org](https://dhall-lang.org)
    ///
    /// `dhall format $PATH`
    DhallFormat,

    #[serde(rename = "dhall:lint")]
    /// Lint Dhall files
    ///
    /// [https://dhall-lang.org](https://dhall-lang.org)
    ///
    /// `dhall lint $PATH`
    DhallLint,

    #[serde(rename = "djade")]
    /// A Django template formatter
    ///
    /// [https://github.com/adamchainz/djade](https://github.com/adamchainz/djade)
    ///
    /// `djade $PATH`
    Djade,

    #[serde(rename = "djlint")]
    /// Lint & Format HTML Templates
    ///
    /// [https://www.djlint.com](https://www.djlint.com)
    ///
    /// `djlint $PATH --reformat`
    Djlint,

    #[serde(rename = "docformatter")]
    /// Formats docstrings to follow PEP 257
    ///
    /// [https://github.com/pycqa/docformatter](https://github.com/pycqa/docformatter)
    ///
    /// `docformatter --in-place $PATH`
    Docformatter,

    #[serde(rename = "dockerfmt")]
    /// Dockerfile formatter. a modern dockfmt
    ///
    /// [https://github.com/reteps/dockerfmt](https://github.com/reteps/dockerfmt)
    ///
    /// `dockerfmt -w -n $PATH`
    Dockerfmt,

    #[serde(rename = "dockfmt")]
    /// Dockerfile format and parser. Like `gofmt` but for Dockerfiles
    ///
    /// [https://github.com/jessfraz/dockfmt](https://github.com/jessfraz/dockfmt)
    ///
    /// `dockfmt fmt -w $PATH`
    Dockfmt,

    #[serde(rename = "docstrfmt")]
    /// A formatter for reStructuredText
    ///
    /// [https://github.com/lilspazjoekp/docstrfmt](https://github.com/lilspazjoekp/docstrfmt)
    ///
    /// `docstrfmt $PATH`
    Docstrfmt,

    #[serde(rename = "doctoc")]
    /// Generates table of contents for markdown files
    ///
    /// [https://github.com/thlorenz/doctoc](https://github.com/thlorenz/doctoc)
    ///
    /// `doctoc $PATH`
    Doctoc,

    #[serde(rename = "dotenv-linter:fix")]
    /// Lightning-fast linter for .env files
    ///
    /// [https://github.com/dotenv-linter/dotenv-linter](https://github.com/dotenv-linter/dotenv-linter)
    ///
    /// `dotenv-linter fix $PATH`
    DotenvLinterFix,

    #[serde(rename = "dprint:fmt")]
    /// A pluggable and configurable code formatting platform written in Rust
    ///
    /// [https://dprint.dev](https://dprint.dev)
    ///
    /// `dprint fmt $PATH`
    DprintFmt,

    #[serde(rename = "dscanner:fix")]
    /// Swiss-army knife for D source code
    ///
    /// [https://github.com/dlang-community/d-scanner](https://github.com/dlang-community/d-scanner)
    ///
    /// `dscanner fix $PATH`
    DscannerFix,

    #[serde(rename = "dscanner:lint")]
    /// Swiss-army knife for D source code
    ///
    /// [https://github.com/dlang-community/d-scanner](https://github.com/dlang-community/d-scanner)
    ///
    /// `dscanner lint $PATH`
    DscannerLint,

    #[serde(rename = "dune:format-dune-file")]
    /// Format dune files
    ///
    /// [https://github.com/ocaml/dune](https://github.com/ocaml/dune)
    ///
    /// `dune format-dune-file`
    DuneFormatDuneFile,

    #[serde(rename = "duster:fix")]
    /// Automatic configuration for Laravel apps to apply Tighten's standard linting & code standards
    ///
    /// [https://github.com/tighten/duster](https://github.com/tighten/duster)
    ///
    /// `duster fix --quiet --no-interaction $PATH`
    DusterFix,

    #[serde(rename = "duster:lint")]
    /// Automatic configuration for Laravel apps to apply Tighten's standard linting & code standards
    ///
    /// [https://github.com/tighten/duster](https://github.com/tighten/duster)
    ///
    /// `duster lint --quiet --no-interaction $PATH`
    DusterLint,

    #[serde(rename = "dx:fmt")]
    /// Format `rsx!` snippets in Rust files
    ///
    /// [https://github.com/dioxuslabs/dioxus](https://github.com/dioxuslabs/dioxus)
    ///
    /// `dx fmt --all-code --file $PATH`
    DxFmt,

    #[serde(rename = "easy-coding-standard")]
    /// The Easiest way to add coding standard to your PHP project
    ///
    /// [https://github.com/easy-coding-standard/easy-coding-standard](https://github.com/easy-coding-standard/easy-coding-standard)
    ///
    /// `ecs check $PATH --fix --no-interaction`
    EasyCodingStandard,

    #[serde(rename = "efmt")]
    /// Erlang code formatter
    ///
    /// [https://github.com/sile/efmt](https://github.com/sile/efmt)
    ///
    /// `efmt -w $PATH`
    Efmt,

    #[serde(rename = "elm-format")]
    /// elm-format formats Elm source code according to a standard set of rules based on the official Elm Style Guide
    ///
    /// [https://github.com/avh4/elm-format](https://github.com/avh4/elm-format)
    ///
    /// `elm-format --elm-version=0.19 --yes $PATH`
    ElmFormat,

    #[serde(rename = "eradicate")]
    /// Removes commented-out code from Python files
    ///
    /// [https://github.com/pycqa/eradicate](https://github.com/pycqa/eradicate)
    ///
    /// `eradicate --in-place $PATH`
    Eradicate,

    #[serde(rename = "erb-formatter")]
    /// Format ERB files with speed and precision
    ///
    /// [https://github.com/nebulab/erb-formatter](https://github.com/nebulab/erb-formatter)
    ///
    /// `erb-format $PATH --write`
    ErbFormatter,

    #[serde(rename = "erg:lint")]
    /// A statically typed language compatible with Python
    ///
    /// [https://github.com/erg-lang/erg](https://github.com/erg-lang/erg)
    ///
    /// `erg lint $PATH`
    ErgLint,

    #[serde(rename = "erlfmt")]
    /// An automated code formatter for Erlang
    ///
    /// [https://github.com/whatsapp/erlfmt](https://github.com/whatsapp/erlfmt)
    ///
    /// `erlfmt -w '$PATH'`
    Erlfmt,

    #[serde(rename = "eslint")]
    /// Find and fix problems in your JavaScript code
    ///
    /// [https://github.com/eslint/eslint](https://github.com/eslint/eslint)
    ///
    /// `eslint --fix $PATH`
    Eslint,

    #[serde(rename = "fantomas")]
    /// FSharp source code formatter
    ///
    /// [https://github.com/fsprojects/fantomas](https://github.com/fsprojects/fantomas)
    ///
    /// `fantomas $PATH`
    Fantomas,

    #[serde(rename = "fish_indent")]
    /// Fish indenter and prettifier
    ///
    /// [https://fishshell.com/docs/current/cmds/fish_indent.html](https://fishshell.com/docs/current/cmds/fish_indent.html)
    ///
    /// `fish_indent -w $PATH`
    FishIndent,

    #[serde(rename = "fixjson")]
    /// JSON Fixer for Humans using (relaxed) JSON5
    ///
    /// [https://github.com/rhysd/fixjson](https://github.com/rhysd/fixjson)
    ///
    /// `fixjson -w $PATH`
    Fixjson,

    #[serde(rename = "floskell")]
    /// Floskell is a flexible Haskell source code pretty printer
    ///
    /// [https://github.com/ennocramer/floskell](https://github.com/ennocramer/floskell)
    ///
    /// `floskell $PATH`
    Floskell,

    #[serde(rename = "flynt")]
    /// A tool to automatically convert old string literal formatting to f-strings
    ///
    /// [https://github.com/ikamensh/flynt](https://github.com/ikamensh/flynt)
    ///
    /// `flynt $PATH`
    Flynt,

    #[serde(rename = "fnlfmt")]
    /// A formatter for Fennel code
    ///
    /// [https://git.sr.ht/~technomancy/fnlfmt](https://git.sr.ht/~technomancy/fnlfmt)
    ///
    /// `fnlfmt $PATH`
    Fnlfmt,

    #[serde(rename = "forge:fmt")]
    /// Format Solidity code
    ///
    /// [https://github.com/foundry-rs/foundry](https://github.com/foundry-rs/foundry)
    ///
    /// `forge fmt $PATH`
    ForgeFmt,

    #[serde(rename = "fortitude:check")]
    /// A Fortran linter
    ///
    /// [https://github.com/plasmafair/fortitude](https://github.com/plasmafair/fortitude)
    ///
    /// `fortitude check --quiet --no-respect-gitignore $PATH`
    FortitudeCheck,

    #[serde(rename = "fortitude:check:fix")]
    /// A Fortran linter
    ///
    /// [https://github.com/plasmafair/fortitude](https://github.com/plasmafair/fortitude)
    ///
    /// `fortitude check --quiet --no-respect-gitignore --fix $PATH`
    FortitudeCheckFix,

    #[serde(rename = "fortitude:check:fix:unsafe")]
    /// A Fortran linter
    ///
    /// [https://github.com/plasmafair/fortitude](https://github.com/plasmafair/fortitude)
    ///
    /// `fortitude check --quiet --no-respect-gitignore --fix --unsafe-fixes $PATH`
    FortitudeCheckFixUnsafe,

    #[serde(rename = "fortran-linter")]
    /// A simple fortran syntax checker, including automatic fixing of the code
    ///
    /// [https://github.com/cphyc/fortran-linter](https://github.com/cphyc/fortran-linter)
    ///
    /// `fortran-linter -i $PATH`
    FortranLinter,

    #[serde(rename = "fourmolu")]
    /// A fourk of ormolu that uses four space indentation and allows arbitrary configuration
    ///
    /// [https://github.com/fourmolu/fourmolu](https://github.com/fourmolu/fourmolu)
    ///
    /// `fourmolu -i $PATH`
    Fourmolu,

    #[serde(rename = "fprettify")]
    /// Auto-formatter for modern Fortran source code
    ///
    /// [https://github.com/fortran-lang/fprettify](https://github.com/fortran-lang/fprettify)
    ///
    /// `fprettify $PATH`
    Fprettify,

    #[serde(rename = "futhark:fmt")]
    /// Code formatter for the furhark programming language
    ///
    /// [https://futhark.readthedocs.io/en/latest/man/futhark-fmt.html](https://futhark.readthedocs.io/en/latest/man/futhark-fmt.html)
    ///
    /// `futhark fmt $PATH`
    FutharkFmt,

    #[serde(rename = "fvm:dart:fix")]
    /// Fixes errors in dart code
    ///
    /// [https://dart.dev/tools/dart-fix](https://dart.dev/tools/dart-fix)
    ///
    /// `fvm dart fix --apply $PATH`
    FvmDartFix,

    #[serde(rename = "fvm:dart:format")]
    /// Formats dart code
    ///
    /// [https://dart.dev/tools/dart-format](https://dart.dev/tools/dart-format)
    ///
    /// `fvm dart format $PATH`
    FvmDartFormat,

    #[serde(rename = "gci")]
    /// GCI, a tool that control golang package import order and make it always deterministic
    ///
    /// [https://github.com/daixiang0/gci](https://github.com/daixiang0/gci)
    ///
    /// `gci write --skip-generated --skip-vendor $PATH`
    Gci,

    #[serde(rename = "gdformat")]
    /// GDScript formatter
    ///
    /// [https://github.com/scony/godot-gdscript-toolkit](https://github.com/scony/godot-gdscript-toolkit)
    ///
    /// `gdformat $PATH`
    Gdformat,

    #[serde(rename = "gdlint")]
    /// GDScript linter
    ///
    /// [https://github.com/scony/godot-gdscript-toolkit](https://github.com/scony/godot-gdscript-toolkit)
    ///
    /// `gdlint $PATH`
    Gdlint,

    #[serde(rename = "gersemi")]
    /// A formatter to make your CMake code the real treasure
    ///
    /// [https://github.com/blankspruce/gersemi](https://github.com/blankspruce/gersemi)
    ///
    /// `gersemi -i -q $PATH`
    Gersemi,

    #[serde(rename = "ghokin:check")]
    /// Parallelized formatter with no external dependencies for gherkin (cucumber, behat...)
    ///
    /// [https://github.com/antham/ghokin](https://github.com/antham/ghokin)
    ///
    /// `ghokin check $PATH`
    GhokinCheck,

    #[serde(rename = "ghokin:fmt")]
    /// Parallelized formatter with no external dependencies for gherkin (cucumber, behat...)
    ///
    /// [https://github.com/antham/ghokin](https://github.com/antham/ghokin)
    ///
    /// `ghokin fmt replace $PATH`
    GhokinFmt,

    #[serde(rename = "gleam:format")]
    /// Format Gleam source code
    ///
    /// [https://gleam.run](https://gleam.run)
    ///
    /// `gleam format $PATH`
    GleamFormat,

    #[serde(rename = "gluon:fmt")]
    /// Code formatting for the gluon programming language
    ///
    /// [https://github.com/gluon-lang/gluon](https://github.com/gluon-lang/gluon)
    ///
    /// `gluon fmt $PATH`
    GluonFmt,

    #[serde(rename = "gofmt")]
    /// Gofmt formats Go programs
    ///
    /// [https://pkg.go.dev/cmd/gofmt](https://pkg.go.dev/cmd/gofmt)
    ///
    /// `gofmt -w $PATH`
    Gofmt,

    #[serde(rename = "gofumpt")]
    /// A stricter gofmt
    ///
    /// [https://github.com/mvdan/gofumpt](https://github.com/mvdan/gofumpt)
    ///
    /// `gofumpt -w $PATH`
    Gofumpt,

    #[serde(rename = "goimports")]
    /// goimports updates your Go import lines, adding missing ones and removing unreferenced ones
    ///
    /// [https://pkg.go.dev/golang.org/x/tools/cmd/goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)
    ///
    /// `goimports -w $PATH`
    Goimports,

    #[serde(rename = "goimports-reviser")]
    /// Right imports sorting & code formatting tool (goimports alternative)
    ///
    /// [https://github.com/incu6us/goimports-reviser](https://github.com/incu6us/goimports-reviser)
    ///
    /// `goimports-reviser -format $PATH`
    GoimportsReviser,

    #[serde(rename = "golangci-lint:fmt")]
    /// Format go source code
    ///
    /// [https://golangci-lint.run/usage/formatters](https://golangci-lint.run/usage/formatters)
    ///
    /// `golangci-lint fmt $PATH`
    GolangciLintFmt,

    #[serde(rename = "golangci-lint:run")]
    /// Fast linters runner for Go
    ///
    /// [https://golangci-lint.run/usage/linters](https://golangci-lint.run/usage/linters)
    ///
    /// `golangci-lint run $PATH`
    GolangciLintRun,

    #[serde(rename = "golangci-lint:run:fix")]
    /// Fast linters runner for Go
    ///
    /// [https://golangci-lint.run/usage/linters](https://golangci-lint.run/usage/linters)
    ///
    /// `golangci-lint run --fix $PATH`
    GolangciLintRunFix,

    #[serde(rename = "golines")]
    /// A golang formatter that fixes long lines
    ///
    /// [https://github.com/golangci/golines](https://github.com/golangci/golines)
    ///
    /// `golines -w $PATH`
    Golines,

    #[serde(rename = "google-java-format")]
    /// Reformats Java source code to comply with Google Java Style
    ///
    /// [https://github.com/google/google-java-format](https://github.com/google/google-java-format)
    ///
    /// `google-java-format -i $PATH`
    GoogleJavaFormat,

    #[serde(rename = "gospel")]
    /// Misspelled word linter for Go comments, string literals and embedded files
    ///
    /// [https://github.com/kortschak/gospel](https://github.com/kortschak/gospel)
    ///
    /// `gospel $PATH`
    Gospel,

    #[serde(rename = "grafbase:lint")]
    /// Lint GraphQL schemas
    ///
    /// [https://grafbase.com/docs/reference/grafbase-cli/lint](https://grafbase.com/docs/reference/grafbase-cli/lint)
    ///
    /// `grafbase lint $PATH`
    GrafbaseLint,

    #[serde(rename = "grain:format")]
    /// Code formatter for the Grain programming language
    ///
    /// [https://grain-lang.org/docs/tooling/grain_cli](https://grain-lang.org/docs/tooling/grain_cli)
    ///
    /// `grain format $PATH -o $PATH`
    GrainFormat,

    #[serde(rename = "hadolint")]
    /// Dockerfile linter, validate inline bash, written in Haskell
    ///
    /// [https://github.com/hadolint/hadolint](https://github.com/hadolint/hadolint)
    ///
    /// `hadolint $PATH`
    Hadolint,

    #[serde(rename = "haml-lint")]
    /// Tool for writing clean and consistent HAML
    ///
    /// [https://github.com/sds/haml-lint](https://github.com/sds/haml-lint)
    ///
    /// `haml-lint --auto-correct $PATH`
    HamlLint,

    #[serde(rename = "hclfmt")]
    /// Formatter for hcl files
    ///
    /// [https://github.com/hashicorp/hcl](https://github.com/hashicorp/hcl)
    ///
    /// `hclfmt -w $PATH`
    Hclfmt,

    #[serde(rename = "hfmt")]
    /// Format Haskell programs. Inspired by the gofmt utility
    ///
    /// [https://github.com/danstiner/hfmt](https://github.com/danstiner/hfmt)
    ///
    /// `hfmt -w $PATH`
    Hfmt,

    #[serde(rename = "hindent")]
    /// Haskell pretty printer
    ///
    /// [https://github.com/mihaimaruseac/hindent](https://github.com/mihaimaruseac/hindent)
    ///
    /// `hindent $PATH`
    Hindent,

    #[serde(rename = "hlint")]
    /// Haskell source code suggestions
    ///
    /// [https://github.com/ndmitchell/hlint](https://github.com/ndmitchell/hlint)
    ///
    /// `hlint $PATH`
    Hlint,

    #[serde(rename = "html-beautify")]
    /// A html formatter
    ///
    /// [https://github.com/beautifier/js-beautify](https://github.com/beautifier/js-beautify)
    ///
    /// `html-beautify -r --type html -f $PATH`
    HtmlBeautify,

    #[serde(rename = "htmlbeautifier")]
    /// A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates
    ///
    /// [https://github.com/threedaymonk/htmlbeautifier](https://github.com/threedaymonk/htmlbeautifier)
    ///
    /// `htmlbeautifier $PATH`
    Htmlbeautifier,

    #[serde(rename = "htmlhint")]
    /// The static code analysis tool you need for your HTML
    ///
    /// [https://github.com/htmlhint/htmlhint](https://github.com/htmlhint/htmlhint)
    ///
    /// `htmlhint $PATH`
    Htmlhint,

    #[serde(rename = "hurlfmt")]
    /// Formatter for hurl files
    ///
    /// [https://hurl.dev](https://hurl.dev)
    ///
    /// `hurlfmt --in-place $PATH`
    Hurlfmt,

    #[serde(rename = "imba:fmt")]
    /// A formatter for Imba
    ///
    /// [https://imba.io](https://imba.io)
    ///
    /// `imba fmt -f $PATH`
    ImbaFmt,

    #[serde(rename = "inko:fmt")]
    /// Code formatter for the inko programming language
    ///
    /// [https://github.com/inko-lang/inko](https://github.com/inko-lang/inko)
    ///
    /// `inko fmt $PATH`
    InkoFmt,

    #[serde(rename = "isort")]
    /// A Python utility to sort imports
    ///
    /// [https://github.com/timothycrosley/isort](https://github.com/timothycrosley/isort)
    ///
    /// `isort --quiet $PATH`
    Isort,

    #[serde(rename = "janet-format")]
    /// A formatter for Janet code
    ///
    /// [https://github.com/janet-lang/spork](https://github.com/janet-lang/spork)
    ///
    /// `janet-format`
    JanetFormat,

    #[serde(rename = "joker")]
    /// Small Clojure interpreter, linter and formatter
    ///
    /// [https://github.com/candid82/joker](https://github.com/candid82/joker)
    ///
    /// `joker --format --write $PATH`
    Joker,

    #[serde(rename = "jq")]
    /// Command-line JSON processor
    ///
    /// [https://github.com/jqlang/jq](https://github.com/jqlang/jq)
    ///
    /// `jq`
    Jq,

    #[serde(rename = "jqfmt")]
    /// like gofmt, but for jq
    ///
    /// [https://github.com/noperator/jqfmt](https://github.com/noperator/jqfmt)
    ///
    /// `jqfmt`
    Jqfmt,

    #[serde(rename = "js-beautify")]
    /// Beautifier for javascript
    ///
    /// [https://github.com/beautifier/js-beautify](https://github.com/beautifier/js-beautify)
    ///
    /// `js-beautify -r --type js -f $PATH`
    JsBeautify,

    #[serde(rename = "json5format")]
    /// JSON5 formatter that preserves contextual comments
    ///
    /// [https://github.com/google/json5format](https://github.com/google/json5format)
    ///
    /// `json5format -r $PATH`
    Json5Format,

    #[serde(rename = "json_repair")]
    /// A module to repair invalid JSON from LLMs
    ///
    /// [https://github.com/mangiucugna/json_repair](https://github.com/mangiucugna/json_repair)
    ///
    /// `json_repair -i $PATH`
    JsonRepair,

    #[serde(rename = "jsona:format")]
    /// Format JSONA
    ///
    /// [https://github.com/jsona/jsona](https://github.com/jsona/jsona)
    ///
    /// `jsona format $PATH`
    JsonaFormat,

    #[serde(rename = "jsona:lint")]
    /// Lint JSONA
    ///
    /// [https://github.com/jsona/jsona](https://github.com/jsona/jsona)
    ///
    /// `jsona lint $PATH`
    JsonaLint,

    #[serde(rename = "jsonlint")]
    /// A JSON parser and validator
    ///
    /// [https://github.com/zaach/jsonlint](https://github.com/zaach/jsonlint)
    ///
    /// `jsonlint -i $PATH`
    Jsonlint,

    #[serde(rename = "jsonlint:sort")]
    /// Sort JSON using jsonlint
    ///
    /// [https://github.com/zaach/jsonlint](https://github.com/zaach/jsonlint)
    ///
    /// `jsonlint -s -i $PATH`
    JsonlintSort,

    #[serde(rename = "jsonnet-lint")]
    /// Linter for jsonnet files
    ///
    /// [https://jsonnet.org/learning/tools.html](https://jsonnet.org/learning/tools.html)
    ///
    /// `jsonnet-lint $PATH`
    JsonnetLint,

    #[serde(rename = "jsonnetfmt")]
    /// Formatter for automatically fixing jsonnet stylistic problems
    ///
    /// [https://jsonnet.org/learning/tools.html](https://jsonnet.org/learning/tools.html)
    ///
    /// `jsonnetfmt -i $PATH`
    Jsonnetfmt,

    #[serde(rename = "jsonpp")]
    /// A fast command line JSON pretty printer
    ///
    /// [https://github.com/jmhodges/jsonpp](https://github.com/jmhodges/jsonpp)
    ///
    /// `jsonpp -s`
    Jsonpp,

    #[serde(rename = "juliaformatter.jl")]
    /// An opinionated code formatter for Julia. Plot twist - the opinion is your own
    ///
    /// [https://github.com/domluna/juliaformatter.jl](https://github.com/domluna/juliaformatter.jl)
    ///
    /// `julia -E using JuliaFormatter;format_file(\"$PATH\")`
    JuliaformatterJl,

    #[serde(rename = "just")]
    /// Format Just files
    ///
    /// [https://github.com/casey/just](https://github.com/casey/just)
    ///
    /// `just --fmt --unstable --justfile $PATH`
    Just,

    #[serde(rename = "kcl:fmt")]
    /// The KCL Format tool supports reformatting KCL files to the standard code style
    ///
    /// [https://www.kcl-lang.io/docs/tools/cli/kcl/fmt](https://www.kcl-lang.io/docs/tools/cli/kcl/fmt)
    ///
    /// `kcl fmt $PATH`
    KclFmt,

    #[serde(rename = "kcl:lint")]
    /// The KCL Lint tool supports checking some warning-level defects in KCL code and supports multiple output formats
    ///
    /// [https://www.kcl-lang.io/docs/tools/cli/kcl/lint](https://www.kcl-lang.io/docs/tools/cli/kcl/lint)
    ///
    /// `kcl lint $PATH`
    KclLint,

    #[serde(rename = "kdlfmt")]
    /// A formatter for kdl documents
    ///
    /// [https://github.com/hougesen/kdlfmt](https://github.com/hougesen/kdlfmt)
    ///
    /// `kdlfmt format $PATH`
    Kdlfmt,

    #[serde(rename = "kdlfmt:v1")]
    /// A formatter for kdl documents
    ///
    /// [https://github.com/hougesen/kdlfmt](https://github.com/hougesen/kdlfmt)
    ///
    /// `kdlfmt format --kdl-version v1 $PATH`
    KdlfmtV1,

    #[serde(rename = "kdlfmt:v2")]
    /// A formatter for kdl documents
    ///
    /// [https://github.com/hougesen/kdlfmt](https://github.com/hougesen/kdlfmt)
    ///
    /// `kdlfmt format --kdl-version v2 $PATH`
    KdlfmtV2,

    #[serde(rename = "kdoc-formatter")]
    /// Reformats Kotlin KDoc comments, reflowing text and other cleanup
    ///
    /// [https://github.com/tnorbye/kdoc-formatter](https://github.com/tnorbye/kdoc-formatter)
    ///
    /// `kdoc-formatter --quiet $PATH`
    KdocFormatter,

    #[serde(rename = "keep-sorted")]
    /// keep-sorted is a language-agnostic formatter that sorts lines between two markers in a larger file
    ///
    /// [https://github.com/google/keep-sorted](https://github.com/google/keep-sorted)
    ///
    /// `keep-sorted $PATH`
    KeepSorted,

    #[serde(rename = "ktfmt")]
    /// A program that reformats Kotlin source code to comply with the common community standard for Kotlin code conventions
    ///
    /// [https://github.com/facebook/ktfmt](https://github.com/facebook/ktfmt)
    ///
    /// `ktfmt $PATH`
    Ktfmt,

    #[serde(rename = "ktlint")]
    /// An anti-bikeshedding Kotlin linter with built-in formatter
    ///
    /// [https://github.com/pinterest/ktlint](https://github.com/pinterest/ktlint)
    ///
    /// `ktlint --format --log-level=error $PATH`
    Ktlint,

    #[serde(rename = "kube-linter:lint")]
    /// KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices
    ///
    /// [https://github.com/stackrox/kube-linter](https://github.com/stackrox/kube-linter)
    ///
    /// `kube-linter lint $PATH`
    KubeLinterLint,

    #[serde(rename = "kulala-fmt:check")]
    /// Check if .http and .rest code is formatted
    ///
    /// [https://github.com/mistweaverco/kulala-fmt](https://github.com/mistweaverco/kulala-fmt)
    ///
    /// `kulala-fmt check $PATH`
    KulalaFmtCheck,

    #[serde(rename = "kulala-fmt:format")]
    /// Format .http and .rest code
    ///
    /// [https://github.com/mistweaverco/kulala-fmt](https://github.com/mistweaverco/kulala-fmt)
    ///
    /// `kulala-fmt format $PATH`
    KulalaFmtFormat,

    #[serde(rename = "leptosfmt")]
    /// A formatter for the leptos view! macro
    ///
    /// [https://github.com/bram209/leptosfmt](https://github.com/bram209/leptosfmt)
    ///
    /// `leptosfmt $PATH`
    Leptosfmt,

    #[serde(rename = "liquidsoap-prettier")]
    /// Prettier plugin for liquidsoap script
    ///
    /// [https://github.com/savonet/liquidsoap-prettier](https://github.com/savonet/liquidsoap-prettier)
    ///
    /// `liquidsoap-prettier --write $PATH`
    LiquidsoapPrettier,

    #[serde(rename = "luacheck")]
    /// A tool for linting and static analysis of Lua code
    ///
    /// [https://github.com/lunarmodules/luacheck](https://github.com/lunarmodules/luacheck)
    ///
    /// `luacheck $PATH`
    Luacheck,

    #[serde(rename = "luaformatter")]
    /// Code formatter for Lua
    ///
    /// [https://github.com/koihik/luaformatter](https://github.com/koihik/luaformatter)
    ///
    /// `lua-format -i $PATH`
    Luaformatter,

    #[serde(rename = "luau-analyze")]
    /// Typecheck and lint luau files
    ///
    /// [https://luau.org](https://luau.org)
    ///
    /// `luau-analyze $PATH`
    LuauAnalyze,

    #[serde(rename = "mado:check")]
    /// A fast Markdown linter written in Rust
    ///
    /// [https://github.com/akiomik/mado](https://github.com/akiomik/mado)
    ///
    /// `mado check $PATH`
    MadoCheck,

    #[serde(rename = "mago:analyze")]
    /// Mago is a toolchain for PHP that aims to provide a set of tools to help developers write better code
    ///
    /// [https://github.com/carthage-software/mago](https://github.com/carthage-software/mago)
    ///
    /// `mago analyze $PATH`
    MagoAnalyze,

    #[serde(rename = "mago:analyze:fix")]
    /// Mago is a toolchain for PHP that aims to provide a set of tools to help developers write better code
    ///
    /// [https://github.com/carthage-software/mago](https://github.com/carthage-software/mago)
    ///
    /// `mago analyze --fix $PATH`
    MagoAnalyzeFix,

    #[serde(rename = "mago:analyze:fix:unsafe")]
    /// Mago is a toolchain for PHP that aims to provide a set of tools to help developers write better code
    ///
    /// [https://github.com/carthage-software/mago](https://github.com/carthage-software/mago)
    ///
    /// `mago analyze --fix --potentially-unsafe --unsafe $PATH`
    MagoAnalyzeFixUnsafe,

    #[serde(rename = "mago:format")]
    /// The format command is used to format PHP files in your project according to the rules defined in your mago.toml configuration file
    ///
    /// [https://mago.carthage.software/#/getting-started/cli?id=mago-format](https://mago.carthage.software/#/getting-started/cli?id=mago-format)
    ///
    /// `mago format $PATH`
    MagoFormat,

    #[serde(rename = "mago:lint")]
    /// The lint command is used to analyze PHP files in your project and report any issues found by the linter
    ///
    /// [https://mago.carthage.software/#/getting-started/cli?id=mago-lint](https://mago.carthage.software/#/getting-started/cli?id=mago-lint)
    ///
    /// `mago lint $PATH`
    MagoLint,

    #[serde(rename = "mago:lint:fix")]
    /// Fix linting errors found by mago lint
    ///
    /// [https://mago.carthage.software/#/getting-started/cli?id=mago-lint](https://mago.carthage.software/#/getting-started/cli?id=mago-lint)
    ///
    /// `mago lint --fix $PATH`
    MagoLintFix,

    #[serde(rename = "mago:lint:fix:unsafe")]
    /// Fix unsafe linting errors found by mago lint
    ///
    /// [https://mago.carthage.software/#/getting-started/cli?id=mago-lint](https://mago.carthage.software/#/getting-started/cli?id=mago-lint)
    ///
    /// `mago lint --fix --potentially-unsafe --unsafe $PATH`
    MagoLintFixUnsafe,

    #[serde(rename = "markdownfmt")]
    /// Like gofmt, but for Markdown
    ///
    /// [https://github.com/shurcool/markdownfmt](https://github.com/shurcool/markdownfmt)
    ///
    /// `markdownfmt -w $PATH`
    Markdownfmt,

    #[serde(rename = "markdownlint")]
    /// A Node.js style checker and lint tool for Markdown/CommonMark files
    ///
    /// [https://github.com/davidanson/markdownlint](https://github.com/davidanson/markdownlint)
    ///
    /// `markdownlint --fix $PATH`
    Markdownlint,

    #[serde(rename = "markdownlint-cli2")]
    /// A fast, flexible, configuration-based command-line interface for linting Markdown/CommonMark files with the markdownlint library
    ///
    /// [https://github.com/davidanson/markdownlint-cli2](https://github.com/davidanson/markdownlint-cli2)
    ///
    /// `markdownlint-cli2 --fix $PATH`
    MarkdownlintCli2,

    #[serde(rename = "markuplint")]
    /// An HTML linter for all markup developers
    ///
    /// [https://markuplint.dev](https://markuplint.dev)
    ///
    /// `markuplint --fix $PATH`
    Markuplint,

    #[serde(rename = "mbake:format")]
    /// mbake is a Makefile formatter and linter
    ///
    /// [https://github.com/ebodshojaei/bake](https://github.com/ebodshojaei/bake)
    ///
    /// `mbake format $PATH`
    MbakeFormat,

    #[serde(rename = "mbake:validate")]
    /// mbake is a Makefile formatter and linter
    ///
    /// [https://github.com/ebodshojaei/bake](https://github.com/ebodshojaei/bake)
    ///
    /// `mbake validate $PATH`
    MbakeValidate,

    #[serde(rename = "md-padding")]
    /// AST-based padding for Markdown and natural language, improving readability in multilingual documents
    ///
    /// [https://github.com/harttle/md-padding](https://github.com/harttle/md-padding)
    ///
    /// `md-padding -i $PATH`
    MdPadding,

    #[serde(rename = "mdformat")]
    /// CommonMark compliant Markdown formatter
    ///
    /// [https://github.com/executablebooks/mdformat](https://github.com/executablebooks/mdformat)
    ///
    /// `mdformat $PATH`
    Mdformat,

    #[serde(rename = "mdsf:format")]
    /// Run mdsf inside mdsf
    ///
    /// [https://github.com/hougesen/mdsf](https://github.com/hougesen/mdsf)
    ///
    /// `mdsf format $PATH`
    MdsfFormat,

    #[serde(rename = "mdsf:verify")]
    /// Run mdsf inside mdsf
    ///
    /// [https://github.com/hougesen/mdsf](https://github.com/hougesen/mdsf)
    ///
    /// `mdsf verify $PATH`
    MdsfVerify,

    #[serde(rename = "mdslw")]
    /// Prepare your markdown for easy diff'ing!
    ///
    /// [https://github.com/razziel89/mdslw](https://github.com/razziel89/mdslw)
    ///
    /// `mdslw $PATH`
    Mdslw,

    #[serde(rename = "meson:fmt")]
    /// Meson is an open source build system meant to be both extremely fast, and, even more importantly, as user friendly as possible
    ///
    /// [https://mesonbuild.com](https://mesonbuild.com)
    ///
    /// `meson fmt -i $PATH`
    MesonFmt,

    #[serde(rename = "mh_lint")]
    /// A linter for MATLAB
    ///
    /// [https://github.com/florianschanda/miss_hit](https://github.com/florianschanda/miss_hit)
    ///
    /// `mh_lint $PATH`
    MhLint,

    #[serde(rename = "mh_style")]
    /// A formatter for MATLAB
    ///
    /// [https://github.com/florianschanda/miss_hit](https://github.com/florianschanda/miss_hit)
    ///
    /// `mh_style $PATH`
    MhStyle,

    #[serde(rename = "mise:fmt")]
    /// Formats mise.toml
    ///
    /// [https://mise.jdx.dev/cli/fmt.html](https://mise.jdx.dev/cli/fmt.html)
    ///
    /// `mise fmt --stdin`
    MiseFmt,

    #[serde(rename = "misspell")]
    /// Correct commonly misspelled English words in source files
    ///
    /// [https://github.com/client9/misspell](https://github.com/client9/misspell)
    ///
    /// `misspell -w $PATH`
    Misspell,

    #[serde(rename = "mix:format")]
    /// Code formatter for Elixir
    ///
    /// [https://hexdocs.pm/mix/main/Mix.Tasks.Format.html](https://hexdocs.pm/mix/main/Mix.Tasks.Format.html)
    ///
    /// `mix format $PATH`
    MixFormat,

    #[serde(rename = "mojo:format")]
    /// Formats Mojo source files
    ///
    /// [https://docs.modular.com/mojo/cli/format](https://docs.modular.com/mojo/cli/format)
    ///
    /// `mojo format -q $PATH`
    MojoFormat,

    #[serde(rename = "muon:fmt")]
    /// Format meson files
    ///
    /// [https://github.com/muon-build/muon](https://github.com/muon-build/muon)
    ///
    /// `muon fmt -i $PATH`
    MuonFmt,

    #[serde(rename = "muon:lint")]
    /// Lint meson files
    ///
    /// [https://github.com/muon-build/muon](https://github.com/muon-build/muon)
    ///
    /// `muon lint -i $PATH`
    MuonLint,

    #[serde(rename = "mypy")]
    /// Optional static typing for Python
    ///
    /// [https://github.com/python/mypy](https://github.com/python/mypy)
    ///
    /// `mypy $PATH`
    Mypy,

    #[serde(rename = "nasmfmt")]
    /// Formatter for NASM source files
    ///
    /// [https://github.com/yamnikov-oleg/nasmfmt](https://github.com/yamnikov-oleg/nasmfmt)
    ///
    /// `nasmfmt $PATH`
    Nasmfmt,

    #[serde(rename = "nginxbeautifier")]
    /// Format and beautify nginx config files
    ///
    /// [https://github.com/vasilevich/nginxbeautifier](https://github.com/vasilevich/nginxbeautifier)
    ///
    /// `nginxbeautifier $PATH`
    Nginxbeautifier,

    #[serde(rename = "nginxfmt")]
    /// nginx config file formatter/beautifier written in Python with no additional dependencies
    ///
    /// [https://github.com/slomkowski/nginx-config-formatter](https://github.com/slomkowski/nginx-config-formatter)
    ///
    /// `nginxfmt $PATH`
    Nginxfmt,

    #[serde(rename = "nickel:format")]
    /// Better configuration for less
    ///
    /// [https://nickel-lang.org](https://nickel-lang.org)
    ///
    /// `nickel format $PATH`
    NickelFormat,

    #[serde(rename = "nimpretty")]
    /// Code formatter for the Nim programming language
    ///
    /// [https://github.com/nim-lang/nim](https://github.com/nim-lang/nim)
    ///
    /// `nimpretty $PATH`
    Nimpretty,

    #[serde(rename = "nixfmt")]
    /// The official formatter for Nix code
    ///
    /// [https://github.com/nixos/nixfmt](https://github.com/nixos/nixfmt)
    ///
    /// `nixfmt $PATH`
    Nixfmt,

    #[serde(rename = "nixpkgs-fmt")]
    /// Nix code formatter for nixpkgs
    ///
    /// [https://github.com/nix-community/nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt)
    ///
    /// `nixpkgs-fmt $PATH`
    NixpkgsFmt,

    #[serde(rename = "nomad:fmt")]
    /// CLI for HashiCorp Nomad
    ///
    /// [https://developer.hashicorp.com/nomad/docs/commands](https://developer.hashicorp.com/nomad/docs/commands)
    ///
    /// `nomad fmt $PATH`
    NomadFmt,

    #[serde(rename = "nph")]
    /// An opinionated code formatter for Nim
    ///
    /// [https://github.com/arnetheduck/nph](https://github.com/arnetheduck/nph)
    ///
    /// `nph $PATH`
    Nph,

    #[serde(rename = "npm-groovy-lint")]
    /// Lint, format and auto-fix your Groovy / Jenkinsfile / Gradle files
    ///
    /// [https://github.com/nvuillam/npm-groovy-lint](https://github.com/nvuillam/npm-groovy-lint)
    ///
    /// `npm-groovy-lint --format $PATH`
    NpmGroovyLint,

    #[serde(rename = "nufmt")]
    /// The nushell formatter
    ///
    /// [https://github.com/nushell/nufmt](https://github.com/nushell/nufmt)
    ///
    /// `nufmt $PATH`
    Nufmt,

    #[serde(rename = "ocamlformat")]
    /// Auto-formatter for OCaml code
    ///
    /// [https://github.com/ocaml-ppx/ocamlformat](https://github.com/ocaml-ppx/ocamlformat)
    ///
    /// `ocamlformat --ignore-invalid-option --inplace --enable-outside-detected-project $PATH`
    Ocamlformat,

    #[serde(rename = "ocp-indent")]
    /// Indentation tool for OCaml
    ///
    /// [https://github.com/ocamlpro/ocp-indent](https://github.com/ocamlpro/ocp-indent)
    ///
    /// `ocp-indent --inplace $PATH`
    OcpIndent,

    #[serde(rename = "odinfmt")]
    /// Formatter for the Odin programming language
    ///
    /// [https://github.com/danielgavin/ols](https://github.com/danielgavin/ols)
    ///
    /// `odinfmt -w $PATH`
    Odinfmt,

    #[serde(rename = "oelint-adv")]
    /// Advanced oelint
    ///
    /// [https://github.com/priv-kweihmann/oelint-adv](https://github.com/priv-kweihmann/oelint-adv)
    ///
    /// `oelint-adv --fix --nobackup --quiet $PATH`
    OelintAdv,

    #[serde(rename = "opa:fmt")]
    /// Format Rego source files
    ///
    /// [https://www.openpolicyagent.org/docs/latest/cli](https://www.openpolicyagent.org/docs/latest/cli)
    ///
    /// `opa fmt $PATH -w`
    OpaFmt,

    #[serde(rename = "ormolu")]
    /// A formatter for Haskell source code
    ///
    /// [https://github.com/tweag/ormolu](https://github.com/tweag/ormolu)
    ///
    /// `ormolu --mode inplace $PATH`
    Ormolu,

    #[serde(rename = "oxfmt")]
    /// Oxfmt a fast JavaScript/TypeScript formatter written in Rust
    ///
    /// [https://oxc.rs/docs/guide/usage/formatter.html](https://oxc.rs/docs/guide/usage/formatter.html)
    ///
    /// `oxfmt $PATH`
    Oxfmt,

    #[serde(rename = "oxlint")]
    /// Oxlint is designed to catch erroneous or useless code without requiring any configurations by default
    ///
    /// [https://oxc.rs/docs/guide/usage/linter.html](https://oxc.rs/docs/guide/usage/linter.html)
    ///
    /// `oxlint --fix $PATH`
    Oxlint,

    #[serde(rename = "packer:fix")]
    /// Takes a template and finds backwards incompatible parts of it and brings it up to date so it can be used with the latest version of Packer
    ///
    /// [https://developer.hashicorp.com/packer/docs/commands/fix](https://developer.hashicorp.com/packer/docs/commands/fix)
    ///
    /// `packer fix $PATH`
    PackerFix,

    #[serde(rename = "packer:fmt")]
    /// Used to format HCL2 configuration files to a canonical format and style
    ///
    /// [https://developer.hashicorp.com/packer/docs/commands](https://developer.hashicorp.com/packer/docs/commands)
    ///
    /// `packer fmt $PATH`
    PackerFmt,

    #[serde(rename = "packer:validate")]
    /// Used to validate the syntax and configuration of a template
    ///
    /// [https://developer.hashicorp.com/packer/docs/commands](https://developer.hashicorp.com/packer/docs/commands)
    ///
    /// `packer validate $PATH`
    PackerValidate,

    #[serde(rename = "pasfmt")]
    /// Delphi code formatter
    ///
    /// [https://github.com/integrated-application-development/pasfmt](https://github.com/integrated-application-development/pasfmt)
    ///
    /// `pasfmt $PATH`
    Pasfmt,

    #[serde(rename = "perflint")]
    /// Python Linter for performance anti patterns
    ///
    /// [https://github.com/tonybaloney/perflint](https://github.com/tonybaloney/perflint)
    ///
    /// `perflint $PATH`
    Perflint,

    #[serde(rename = "perltidy")]
    /// Perl::Tidy, a source code formatter for Perl
    ///
    /// [https://github.com/perltidy/perltidy](https://github.com/perltidy/perltidy)
    ///
    /// `perltidy -b $PATH`
    Perltidy,

    #[serde(rename = "pg_format")]
    /// A PostgreSQL SQL syntax beautifier
    ///
    /// [https://github.com/darold/pgformatter](https://github.com/darold/pgformatter)
    ///
    /// `pg_format --inplace $PATH`
    PgFormat,

    #[serde(rename = "php-cs-fixer:fix")]
    /// A tool to automatically fix PHP Coding Standards issues
    ///
    /// [https://github.com/php-cs-fixer/php-cs-fixer](https://github.com/php-cs-fixer/php-cs-fixer)
    ///
    /// `php-cs-fixer fix $PATH`
    PhpCsFixerFix,

    #[serde(rename = "phpcbf")]
    /// PHP Code Beautifier and Fixer fixes violations of a defined coding standard
    ///
    /// [https://github.com/phpcsstandards/php_codesniffer](https://github.com/phpcsstandards/php_codesniffer)
    ///
    /// `phpcbf $PATH`
    Phpcbf,

    #[serde(rename = "phpinsights:fix")]
    /// Instant PHP quality checks from your console
    ///
    /// [https://github.com/nunomaduro/phpinsights](https://github.com/nunomaduro/phpinsights)
    ///
    /// `phpinsights fix $PATH --no-interaction --quiet`
    PhpinsightsFix,

    #[serde(rename = "pint")]
    /// Laravel Pint is an opinionated PHP code style fixer for minimalists
    ///
    /// [https://github.com/laravel/pint](https://github.com/laravel/pint)
    ///
    /// `pint $PATH`
    Pint,

    #[serde(rename = "pkl:format")]
    /// Formats or checks formatting of Pkl files
    ///
    /// [https://pkl-lang.org/main/current/pkl-cli/index.html#command-format](https://pkl-lang.org/main/current/pkl-cli/index.html#command-format)
    ///
    /// `pkl -w $PATH`
    PklFormat,

    #[serde(rename = "prettier")]
    /// Prettier is an opinionated code formatter
    ///
    /// [https://github.com/prettier/prettier](https://github.com/prettier/prettier)
    ///
    /// `prettier --embedded-language-formatting off --log-level error --write $PATH`
    Prettier,

    #[serde(rename = "prettierd")]
    /// prettier, as a daemon, for improved formatting speed
    ///
    /// [https://github.com/fsouza/prettierd](https://github.com/fsouza/prettierd)
    ///
    /// `prettierd $PATH`
    Prettierd,

    #[serde(rename = "pretty-php")]
    /// The opinionated PHP code formatter
    ///
    /// [https://github.com/lkrms/pretty-php](https://github.com/lkrms/pretty-php)
    ///
    /// `pretty-php $PATH`
    PrettyPhp,

    #[serde(rename = "prettypst")]
    /// Formatter for Typst
    ///
    /// [https://github.com/antonwetzel/prettypst](https://github.com/antonwetzel/prettypst)
    ///
    /// `prettypst $PATH`
    Prettypst,

    #[serde(rename = "prisma:format")]
    /// Commands for interacting with the prisma ORM
    ///
    /// [https://www.prisma.io/docs/orm/tools/prisma-cli](https://www.prisma.io/docs/orm/tools/prisma-cli)
    ///
    /// `prisma format --schema=$PATH`
    PrismaFormat,

    #[serde(rename = "proselint")]
    /// A linter for prose
    ///
    /// [https://github.com/amperser/proselint](https://github.com/amperser/proselint)
    ///
    /// `proselint $PATH`
    Proselint,

    #[serde(rename = "protolint")]
    /// A pluggable linter and fixer to enforce Protocol Buffer style and conventions
    ///
    /// [https://github.com/yoheimuta/protolint](https://github.com/yoheimuta/protolint)
    ///
    /// `protolint lint -fix $PATH`
    Protolint,

    #[serde(rename = "ptop")]
    /// Free Pascal source formatter
    ///
    /// [https://www.freepascal.org/tools/ptop.html](https://www.freepascal.org/tools/ptop.html)
    ///
    /// `ptop $PATH $PATH`
    Ptop,

    #[serde(rename = "pug-lint")]
    /// An unopinionated and configurable linter and style checker for Pug
    ///
    /// [https://github.com/pugjs/pug-lint](https://github.com/pugjs/pug-lint)
    ///
    /// `pug-lint $PATH`
    PugLint,

    #[serde(rename = "puppet-lint")]
    /// Check that your Puppet manifests conform to the style guide
    ///
    /// [https://github.com/puppetlabs/puppet-lint](https://github.com/puppetlabs/puppet-lint)
    ///
    /// `puppet-lint --fix $PATH`
    PuppetLint,

    #[serde(rename = "purs-tidy")]
    /// A syntax tidy-upper for PureScript
    ///
    /// [https://github.com/natefaubion/purescript-tidy](https://github.com/natefaubion/purescript-tidy)
    ///
    /// `purs-tidy format-in-place $PATH`
    PursTidy,

    #[serde(rename = "purty")]
    /// PureScript pretty-printer
    ///
    /// [https://gitlab.com/joneshf/purty](https://gitlab.com/joneshf/purty)
    ///
    /// `purty --write $PATH`
    Purty,

    #[serde(rename = "pycln")]
    /// A formatter for finding and removing unused import statements
    ///
    /// [https://github.com/hadialqattan/pycln](https://github.com/hadialqattan/pycln)
    ///
    /// `pycln --no-gitignore --quiet $PATH`
    Pycln,

    #[serde(rename = "pycodestyle")]
    /// Simple Python style checker in one Python file
    ///
    /// [https://github.com/pycqa/pycodestyle](https://github.com/pycqa/pycodestyle)
    ///
    /// `pycodestyle $PATH`
    Pycodestyle,

    #[serde(rename = "pydoclint")]
    /// A very fast Python docstring linter
    ///
    /// [https://github.com/jsh9/pydoclint](https://github.com/jsh9/pydoclint)
    ///
    /// `pydoclint $PATH`
    Pydoclint,

    #[serde(rename = "pydocstringformatter")]
    /// Automatically format your Python docstrings to conform with PEP 8 and PEP 257
    ///
    /// [https://github.com/danielnoord/pydocstringformatter](https://github.com/danielnoord/pydocstringformatter)
    ///
    /// `pydocstringformatter -w $PATH`
    Pydocstringformatter,

    #[serde(rename = "pydocstyle")]
    /// docstring style checker
    ///
    /// [https://github.com/pycqa/pydocstyle](https://github.com/pycqa/pydocstyle)
    ///
    /// `pydocstyle $PATH`
    Pydocstyle,

    #[serde(rename = "pyflakes")]
    /// A simple program which checks Python source files for errors
    ///
    /// [https://github.com/pycqa/pyflakes](https://github.com/pycqa/pyflakes)
    ///
    /// `pyflakes $PATH`
    Pyflakes,

    #[serde(rename = "pyink")]
    /// Pyink is a Python formatter, forked from Black with a few different formatting behaviors
    ///
    /// [https://github.com/google/pyink](https://github.com/google/pyink)
    ///
    /// `pyink --quiet $PATH`
    Pyink,

    #[serde(rename = "pylint")]
    /// Pylint is a static code analyser for Python 2 and 3
    ///
    /// [https://github.com/pylint-dev/pylint](https://github.com/pylint-dev/pylint)
    ///
    /// `pylint --module-naming-style=any $PATH`
    Pylint,

    #[serde(rename = "pymarkdownlnt:fix")]
    /// A GitHub Flavored Markdown compliant Markdown linter
    ///
    /// [https://github.com/jackdewinter/pymarkdown](https://github.com/jackdewinter/pymarkdown)
    ///
    /// `pymarkdownlnt --return-code-scheme minimal fix $PATH`
    PymarkdownlntFix,

    #[serde(rename = "pyment")]
    /// Format and convert Python docstrings and generates patches
    ///
    /// [https://github.com/dadadel/pyment](https://github.com/dadadel/pyment)
    ///
    /// `pyment -w $PATH`
    Pyment,

    #[serde(rename = "pyrefly")]
    /// A fast type checker for Python
    ///
    /// [https://github.com/facebook/pyrefly](https://github.com/facebook/pyrefly)
    ///
    /// `pyrefly check $PATH`
    Pyrefly,

    #[serde(rename = "pyupgrade")]
    /// A tool to automatically upgrade Python syntax to newer versions
    ///
    /// [https://github.com/asottile/pyupgrade](https://github.com/asottile/pyupgrade)
    ///
    /// `pyupgrade --exit-zero-even-if-changed $PATH`
    Pyupgrade,

    #[serde(rename = "qmlfmt")]
    /// Command line application that formats QML files
    ///
    /// [https://github.com/jesperhh/qmlfmt](https://github.com/jesperhh/qmlfmt)
    ///
    /// `qmlfmt -w $PATH`
    Qmlfmt,

    #[serde(rename = "qmlformat")]
    /// qmlformat is a tool that automatically formats QML files in accordance with the QML Coding Conventions
    ///
    /// [https://doc.qt.io/qt-6/qtqml-tooling-qmlformat.html](https://doc.qt.io/qt-6/qtqml-tooling-qmlformat.html)
    ///
    /// `qmlformat -i $PATH`
    Qmlformat,

    #[serde(rename = "qmllint")]
    /// qmllint is a tool shipped with Qt, that verifies the syntactic validity of QML files
    ///
    /// [https://doc.qt.io/qt-6/qtqml-tooling-qmllint.html](https://doc.qt.io/qt-6/qtqml-tooling-qmllint.html)
    ///
    /// `qmllint $PATH`
    Qmllint,

    #[serde(rename = "quick-lint-js")]
    /// quick-lint-js finds bugs in JavaScript programs
    ///
    /// [https://github.com/quick-lint/quick-lint-js](https://github.com/quick-lint/quick-lint-js)
    ///
    /// `quick-lint-js $PATH`
    QuickLintJs,

    #[serde(rename = "raco:fmt")]
    /// An extensible code formatter for Racket
    ///
    /// [https://docs.racket-lang.org/fmt](https://docs.racket-lang.org/fmt)
    ///
    /// `raco fmt -i $PATH`
    RacoFmt,

    #[serde(rename = "reek")]
    /// Code smell detector for Ruby
    ///
    /// [https://github.com/troessner/reek](https://github.com/troessner/reek)
    ///
    /// `reek $PATH`
    Reek,

    #[serde(rename = "refmt")]
    /// refmt stands by Reason Formatter and it formats Reason programs, is a parser and pretty-printer for Reason
    ///
    /// [https://reasonml.github.io/docs/en/refmt](https://reasonml.github.io/docs/en/refmt)
    ///
    /// `refmt --in-place $PATH`
    Refmt,

    #[serde(rename = "reformat-gherkin")]
    /// Formatter for Gherkin language
    ///
    /// [https://github.com/ducminh-phan/reformat-gherkin](https://github.com/ducminh-phan/reformat-gherkin)
    ///
    /// `reformat-gherkin $PATH`
    ReformatGherkin,

    #[serde(rename = "refurb")]
    /// A tool for refurbishing and modernizing Python codebases
    ///
    /// [https://github.com/dosisod/refurb](https://github.com/dosisod/refurb)
    ///
    /// `refurb $PATH`
    Refurb,

    #[serde(rename = "regal:fix")]
    /// Lint and fix Rego code errors
    ///
    /// [https://github.com/styrainc/regal](https://github.com/styrainc/regal)
    ///
    /// `regal fix $PATH`
    RegalFix,

    #[serde(rename = "regal:lint")]
    /// Lint Rego code
    ///
    /// [https://github.com/styrainc/regal](https://github.com/styrainc/regal)
    ///
    /// `regal lint $PATH`
    RegalLint,

    #[serde(rename = "reorder-python-imports")]
    /// Rewrites source to reorder python imports
    ///
    /// [https://github.com/asottile/reorder-python-imports](https://github.com/asottile/reorder-python-imports)
    ///
    /// `reorder-python-imports --exit-zero-even-if-changed $PATH`
    ReorderPythonImports,

    #[serde(rename = "rescript:format")]
    /// Formatter for ReScript
    ///
    /// [https://github.com/rescript-lang/rescript](https://github.com/rescript-lang/rescript)
    ///
    /// `rescript format $PATH`
    RescriptFormat,

    #[serde(rename = "revive")]
    /// ~6x faster, stricter, configurable, extensible, and beautiful drop-in replacement for golint
    ///
    /// [https://github.com/mgechev/revive](https://github.com/mgechev/revive)
    ///
    /// `revive $PATH`
    Revive,

    #[serde(rename = "roc:format")]
    /// Format Roc code
    ///
    /// [https://github.com/roc-lang/roc](https://github.com/roc-lang/roc)
    ///
    /// `roc format $PATH`
    RocFormat,

    #[serde(rename = "rstfmt")]
    /// A formatter for reStructuredText
    ///
    /// [https://github.com/dzhu/rstfmt](https://github.com/dzhu/rstfmt)
    ///
    /// `rstfmt $PATH`
    Rstfmt,

    #[serde(rename = "rubocop")]
    /// A Ruby static code analyzer and formatter, based on the community Ruby style guide
    ///
    /// [https://github.com/rubocop/rubocop](https://github.com/rubocop/rubocop)
    ///
    /// `rubocop --fix-layout --autocorrect --format quiet $PATH`
    Rubocop,

    #[serde(rename = "rubyfmt")]
    /// Ruby Autoformatter
    ///
    /// [https://github.com/fables-tales/rubyfmt](https://github.com/fables-tales/rubyfmt)
    ///
    /// `rubyfmt -i $PATH`
    Rubyfmt,

    #[serde(rename = "ruff:check")]
    /// Run the Ruff linter on the input
    ///
    /// [https://github.com/astral-sh/ruff](https://github.com/astral-sh/ruff)
    ///
    /// `ruff check --fix --quiet $PATH`
    RuffCheck,

    #[serde(rename = "ruff:format")]
    /// Run the Ruff formatter on the input
    ///
    /// [https://github.com/astral-sh/ruff](https://github.com/astral-sh/ruff)
    ///
    /// `ruff format --quiet $PATH`
    RuffFormat,

    #[serde(rename = "rufo")]
    /// The Ruby Formatter
    ///
    /// [https://github.com/ruby-formatter/rufo](https://github.com/ruby-formatter/rufo)
    ///
    /// `rufo --simple-exit $PATH`
    Rufo,

    #[serde(rename = "rumdl:check")]
    /// Lint Markdown
    ///
    /// [https://github.com/rvben/rumdl](https://github.com/rvben/rumdl)
    ///
    /// `rumdl check $PATH`
    RumdlCheck,

    #[serde(rename = "rumdl:check:fix")]
    /// Lint Markdown and fix errors
    ///
    /// [https://github.com/rvben/rumdl](https://github.com/rvben/rumdl)
    ///
    /// `rumdl check --fix $PATH`
    RumdlCheckFix,

    #[serde(rename = "rumdl:fmt")]
    /// Format markdown
    ///
    /// [https://github.com/rvben/rumdl](https://github.com/rvben/rumdl)
    ///
    /// `rumdl fmt $PATH`
    RumdlFmt,

    #[serde(rename = "rune:fmt")]
    /// Format Rune source code
    ///
    /// [https://github.com/rune-rs/rune](https://github.com/rune-rs/rune)
    ///
    /// `rune fmt $PATH`
    RuneFmt,

    #[serde(rename = "runic")]
    /// A code formatter for Julia with rules set in stone
    ///
    /// [https://github.com/fredrikekre/runic.jl](https://github.com/fredrikekre/runic.jl)
    ///
    /// `runic --inplace $PATH`
    Runic,

    #[serde(rename = "rustfmt")]
    /// Format Rust code
    ///
    /// [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)
    ///
    /// `rustfmt --edition 2024 --quiet $PATH`
    Rustfmt,

    #[serde(rename = "rustfmt:2015")]
    /// Format Rust code
    ///
    /// [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)
    ///
    /// `rustfmt --edition 2015 --quiet $PATH`
    Rustfmt2015,

    #[serde(rename = "rustfmt:2018")]
    /// Format Rust code
    ///
    /// [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)
    ///
    /// `rustfmt --edition 2018 --quiet $PATH`
    Rustfmt2018,

    #[serde(rename = "rustfmt:2021")]
    /// Format Rust code
    ///
    /// [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)
    ///
    /// `rustfmt --edition 2021 --quiet $PATH`
    Rustfmt2021,

    #[serde(rename = "rustfmt:2024")]
    /// Format Rust code
    ///
    /// [https://github.com/rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)
    ///
    /// `rustfmt --edition 2024 --quiet $PATH`
    Rustfmt2024,

    #[serde(rename = "rustywind")]
    /// CLI for organizing Tailwind CSS classes
    ///
    /// [https://github.com/avencera/rustywind](https://github.com/avencera/rustywind)
    ///
    /// `rustywind --write $PATH`
    Rustywind,

    #[serde(rename = "salt-lint")]
    /// A command-line utility that checks for best practices in SaltStack
    ///
    /// [https://github.com/warpnet/salt-lint](https://github.com/warpnet/salt-lint)
    ///
    /// `salt-lint $PATH`
    SaltLint,

    #[serde(rename = "scala")]
    /// Code formatter for Scala
    ///
    /// [https://www.scala-lang.org](https://www.scala-lang.org)
    ///
    /// `scala fmt $PATH`
    Scala,

    #[serde(rename = "scalafmt")]
    /// Code formatter for Scala
    ///
    /// [https://github.com/scalameta/scalafmt](https://github.com/scalameta/scalafmt)
    ///
    /// `scalafmt --quiet --mode any $PATH`
    Scalafmt,

    #[serde(rename = "scalariform")]
    /// Scala source code formatter
    ///
    /// [https://github.com/scala-ide/scalariform](https://github.com/scala-ide/scalariform)
    ///
    /// `scalariform $PATH`
    Scalariform,

    #[serde(rename = "selene")]
    /// A blazing-fast modern Lua linter written in Rust
    ///
    /// [https://github.com/kampfkarren/selene](https://github.com/kampfkarren/selene)
    ///
    /// `selene --no-summary --quiet $PATH`
    Selene,

    #[serde(rename = "semistandard")]
    /// All the goodness of standardjs with semicolons sprinkled on top
    ///
    /// [https://github.com/standard/semistandard](https://github.com/standard/semistandard)
    ///
    /// `semistandard --fix --stdin`
    Semistandard,

    #[serde(rename = "shellcheck")]
    /// ShellCheck, a static analysis tool for shell scripts
    ///
    /// [https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck)
    ///
    /// `shellcheck $PATH`
    Shellcheck,

    #[serde(rename = "shellharden")]
    /// The corrective bash syntax highlighter
    ///
    /// [https://github.com/anordal/shellharden](https://github.com/anordal/shellharden)
    ///
    /// `shellharden --transform --replace $PATH`
    Shellharden,

    #[serde(rename = "shfmt")]
    /// A shell parser, formatter, and interpreter with bash support
    ///
    /// [https://github.com/mvdan/sh](https://github.com/mvdan/sh)
    ///
    /// `shfmt --write $PATH`
    Shfmt,

    #[serde(rename = "sleek")]
    /// Sleek is a CLI tool for formatting SQL. It helps you maintain a consistent style across your SQL code, enhancing readability and productivity
    ///
    /// [https://github.com/nrempel/sleek](https://github.com/nrempel/sleek)
    ///
    /// `sleek $PATH`
    Sleek,

    #[serde(rename = "slim-lint")]
    /// Configurable tool for analyzing Slim templates
    ///
    /// [https://github.com/sds/slim-lint](https://github.com/sds/slim-lint)
    ///
    /// `slim-lint $PATH`
    SlimLint,

    #[serde(rename = "smlfmt")]
    /// A custom parser/auto-formatter for Standard ML
    ///
    /// [https://github.com/shwestrick/smlfmt](https://github.com/shwestrick/smlfmt)
    ///
    /// `smlfmt --force $PATH`
    Smlfmt,

    #[serde(rename = "snakefmt")]
    /// The uncompromising Snakemake code formatter
    ///
    /// [https://github.com/snakemake/snakefmt](https://github.com/snakemake/snakefmt)
    ///
    /// `snakefmt $PATH`
    Snakefmt,

    #[serde(rename = "solhint")]
    /// Solhint is an open-source project to provide a linting utility for Solidity code
    ///
    /// [https://github.com/protofire/solhint](https://github.com/protofire/solhint)
    ///
    /// `solhint --quiet --fix --noPrompt $PATH`
    Solhint,

    #[serde(rename = "sphinx-lint")]
    /// Check for stylistic and formal issues in .rst and .py files included in the documentation
    ///
    /// [https://github.com/sphinx-contrib/sphinx-lint](https://github.com/sphinx-contrib/sphinx-lint)
    ///
    /// `sphinx-lint $PATH`
    SphinxLint,

    #[serde(rename = "sql-formatter")]
    /// A whitespace formatter for different query languages
    ///
    /// [https://github.com/sql-formatter-org/sql-formatter](https://github.com/sql-formatter-org/sql-formatter)
    ///
    /// `sql-formatter --fix $PATH`
    SqlFormatter,

    #[serde(rename = "sqlfluff:fix")]
    /// Fix SQL errors
    ///
    /// [https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-fix](https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-fix)
    ///
    /// `sqlfluff fix --disable-progress-bar --nocolor --dialect ansi $PATH`
    SqlfluffFix,

    #[serde(rename = "sqlfluff:format")]
    /// Format SQL
    ///
    /// [https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-format](https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-format)
    ///
    /// `sqlfluff format --disable-progress-bar --nocolor --dialect ansi $PATH`
    SqlfluffFormat,

    #[serde(rename = "sqlfluff:lint")]
    /// Lint SQL
    ///
    /// [https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-lint](https://docs.sqlfluff.com/en/stable/reference/cli.html#sqlfluff-lint)
    ///
    /// `sqlfluff lint --disable-progress-bar --nocolor --dialect ansi $PATH`
    SqlfluffLint,

    #[serde(rename = "sqlfmt")]
    /// sqlfmt formats your dbt SQL files so you don't have to
    ///
    /// [https://github.com/tconbeer/sqlfmt](https://github.com/tconbeer/sqlfmt)
    ///
    /// `sqlfmt $PATH`
    Sqlfmt,

    #[serde(rename = "sqlint")]
    /// Simple SQL linter supporting ANSI and PostgreSQL syntaxes
    ///
    /// [https://github.com/purcell/sqlint](https://github.com/purcell/sqlint)
    ///
    /// `sqlint $PATH`
    Sqlint,

    #[serde(rename = "sqruff")]
    /// Fast SQL formatter/linter
    ///
    /// [https://github.com/quarylabs/sqruff](https://github.com/quarylabs/sqruff)
    ///
    /// `sqruff fix $PATH`
    Sqruff,

    #[serde(rename = "squawk")]
    /// Linter for Postgres migrations & SQL
    ///
    /// [https://github.com/sbdchd/squawk](https://github.com/sbdchd/squawk)
    ///
    /// `squawk $PATH`
    Squawk,

    #[serde(rename = "standardjs")]
    /// JavaScript Style Guide, with linter & automatic code fixer
    ///
    /// [https://github.com/standard/standard](https://github.com/standard/standard)
    ///
    /// `standard --fix --stdin`
    Standardjs,

    #[serde(rename = "standardrb")]
    /// Ruby's bikeshed-proof linter and formatter
    ///
    /// [https://github.com/standardrb/standard](https://github.com/standardrb/standard)
    ///
    /// `standardrb --fix $PATH`
    Standardrb,

    #[serde(rename = "statix:check")]
    /// Finds errors in Nix code
    ///
    /// [https://github.com/oppiliappan/statix](https://github.com/oppiliappan/statix)
    ///
    /// `statix check $PATH`
    StatixCheck,

    #[serde(rename = "statix:fix")]
    /// Fixes errors in Nix code
    ///
    /// [https://github.com/oppiliappan/statix](https://github.com/oppiliappan/statix)
    ///
    /// `statix fix $PATH`
    StatixFix,

    #[serde(rename = "stylefmt")]
    /// stylefmt is a tool that automatically formats stylesheets
    ///
    /// [https://github.com/matype/stylefmt](https://github.com/matype/stylefmt)
    ///
    /// `stylefmt $PATH`
    Stylefmt,

    #[serde(rename = "stylelint")]
    /// A mighty CSS linter that helps you avoid errors and enforce conventions
    ///
    /// [https://github.com/stylelint/stylelint](https://github.com/stylelint/stylelint)
    ///
    /// `stylelint --fix $PATH`
    Stylelint,

    #[serde(rename = "stylish-haskell")]
    /// Haskell code prettifier
    ///
    /// [https://github.com/haskell/stylish-haskell](https://github.com/haskell/stylish-haskell)
    ///
    /// `stylish-haskell --inplace $PATH`
    StylishHaskell,

    #[serde(rename = "stylua")]
    /// A Lua code formatter
    ///
    /// [https://github.com/johnnymorganz/stylua](https://github.com/johnnymorganz/stylua)
    ///
    /// `stylua --verify $PATH`
    Stylua,

    #[serde(rename = "superhtml:fmt")]
    /// HTML Validator, Formatter, LSP, and Templating Language Library
    ///
    /// [https://github.com/kristoff-it/superhtml](https://github.com/kristoff-it/superhtml)
    ///
    /// `superhtml fmt $PATH`
    SuperhtmlFmt,

    #[serde(rename = "svlint")]
    /// SystemVerilog linter
    ///
    /// [https://github.com/dalance/svlint](https://github.com/dalance/svlint)
    ///
    /// `svlint $PATH`
    Svlint,

    #[serde(rename = "swift-format")]
    /// Formatting technology for Swift source code
    ///
    /// [https://github.com/swiftlang/swift-format](https://github.com/swiftlang/swift-format)
    ///
    /// `swift-format --in-place $PATH`
    SwiftFormat,

    #[serde(rename = "swiftformat")]
    /// A command-line tool and Xcode Extension for formatting Swift code
    ///
    /// [https://github.com/nicklockwood/swiftformat](https://github.com/nicklockwood/swiftformat)
    ///
    /// `swiftformat --quiet $PATH`
    Swiftformat,

    #[serde(rename = "swiftlint")]
    /// A tool to enforce Swift style and conventions
    ///
    /// [https://github.com/realm/swiftlint](https://github.com/realm/swiftlint)
    ///
    /// `swiftlint $PATH`
    Swiftlint,

    #[serde(rename = "taplo")]
    /// A TOML toolkit written in Rust
    ///
    /// [https://github.com/tamasfe/taplo](https://github.com/tamasfe/taplo)
    ///
    /// `taplo format $PATH`
    Taplo,

    #[serde(rename = "tclfmt")]
    /// Formatter for Tcl
    ///
    /// [https://github.com/nmoroze/tclint](https://github.com/nmoroze/tclint)
    ///
    /// `tclfmt $PATH`
    Tclfmt,

    #[serde(rename = "tclint")]
    /// Linter for Tcl
    ///
    /// [https://github.com/nmoroze/tclint](https://github.com/nmoroze/tclint)
    ///
    /// `tclint $PATH`
    Tclint,

    #[serde(rename = "templ:fmt")]
    /// Format Templ files
    ///
    /// [https://github.com/a-h/templ](https://github.com/a-h/templ)
    ///
    /// `templ fmt $PATH`
    TemplFmt,

    #[serde(rename = "terraform:fmt")]
    /// The terraform fmt command is used to rewrite Terraform configuration files to a canonical format and style
    ///
    /// [https://www.terraform.io/docs/cli/commands/fmt.html](https://www.terraform.io/docs/cli/commands/fmt.html)
    ///
    /// `terraform fmt -write=true $PATH`
    TerraformFmt,

    #[serde(rename = "terragrunt:hclfmt")]
    /// Recursively find hcl files and rewrite them into a canonical format
    ///
    /// [https://terragrunt.gruntwork.io/docs/reference/cli-options/#hclfmt](https://terragrunt.gruntwork.io/docs/reference/cli-options/#hclfmt)
    ///
    /// `terragrunt hclfmt --terragrunt-hclfmt-file $PATH`
    TerragruntHclfmt,

    #[serde(rename = "tex-fmt")]
    /// An extremely fast LaTeX formatter written in Rust
    ///
    /// [https://github.com/wgunderwood/tex-fmt](https://github.com/wgunderwood/tex-fmt)
    ///
    /// `tex-fmt $PATH`
    TexFmt,

    #[serde(rename = "textlint")]
    /// Check input for prose errors
    ///
    /// [https://github.com/textlint/textlint](https://github.com/textlint/textlint)
    ///
    /// `textlint $PATH`
    Textlint,

    #[serde(rename = "textlint:fix")]
    /// Tries to fix prose errors
    ///
    /// [https://github.com/textlint/textlint](https://github.com/textlint/textlint)
    ///
    /// `textlint --fix $PATH`
    TextlintFix,

    #[serde(rename = "tlint:format")]
    /// Tighten linter for Laravel conventions
    ///
    /// [https://github.com/tighten/tlint](https://github.com/tighten/tlint)
    ///
    /// `tlint format $PATH`
    TlintFormat,

    #[serde(rename = "tofu:fmt")]
    /// The tofu fmt command is used to rewrite OpenTofu configuration files to a canonical format and style
    ///
    /// [https://opentofu.org/docs/cli/commands/fmt](https://opentofu.org/docs/cli/commands/fmt)
    ///
    /// `tofu fmt -write=true $PATH`
    TofuFmt,

    #[serde(rename = "tombi:format")]
    /// TOML Formatter / Linter
    ///
    /// [https://github.com/tombi-toml/tombi](https://github.com/tombi-toml/tombi)
    ///
    /// `tombi format -`
    TombiFormat,

    #[serde(rename = "tombi:lint")]
    /// TOML Formatter / Linter
    ///
    /// [https://github.com/tombi-toml/tombi](https://github.com/tombi-toml/tombi)
    ///
    /// `tombi lint $PATH`
    TombiLint,

    #[serde(rename = "toml-sort")]
    /// A command line utility to sort and format toml files
    ///
    /// [https://github.com/pappasam/toml-sort](https://github.com/pappasam/toml-sort)
    ///
    /// `toml-sort -i $PATH`
    TomlSort,

    #[serde(rename = "topiary")]
    /// Topiary aims to be a uniform formatter for simple languages, as part of the Tree-sitter ecosystem
    ///
    /// [https://github.com/tweag/topiary](https://github.com/tweag/topiary)
    ///
    /// `topiary format $PATH`
    Topiary,

    #[serde(rename = "tryceratops")]
    /// A linter to prevent exception handling antipatterns in Python
    ///
    /// [https://github.com/guilatrova/tryceratops](https://github.com/guilatrova/tryceratops)
    ///
    /// `tryceratops --autofix $PATH`
    Tryceratops,

    #[serde(rename = "ts-standard")]
    /// Typescript style guide, linter, and formatter using StandardJS
    ///
    /// [https://github.com/standard/ts-standard](https://github.com/standard/ts-standard)
    ///
    /// `ts-standard --fix $PATH`
    TsStandard,

    #[serde(rename = "tsp:format")]
    /// Format TypeSpec files
    ///
    /// [https://github.com/microsoft/typespec](https://github.com/microsoft/typespec)
    ///
    /// `tsp format $PATH`
    TspFormat,

    #[serde(rename = "tsqllint")]
    /// Configurable linting for TSQL
    ///
    /// [https://github.com/tsqllint/tsqllint](https://github.com/tsqllint/tsqllint)
    ///
    /// `tsqllint --fix $PATH`
    Tsqllint,

    #[serde(rename = "twig-cs-fixer:check")]
    /// A tool to automatically fix Twig Coding Standards issues
    ///
    /// [https://github.com/vincentlanglet/twig-cs-fixer](https://github.com/vincentlanglet/twig-cs-fixer)
    ///
    /// `twig-cs-fixer check $PATH --no-interaction`
    TwigCsFixerCheck,

    #[serde(rename = "twig-cs-fixer:fix")]
    /// A tool to automatically fix Twig Coding Standards issues
    ///
    /// [https://github.com/vincentlanglet/twig-cs-fixer](https://github.com/vincentlanglet/twig-cs-fixer)
    ///
    /// `twig-cs-fixer fix $PATH --no-interaction`
    TwigCsFixerFix,

    #[serde(rename = "twig-cs-fixer:lint")]
    /// A tool to automatically fix Twig Coding Standards issues
    ///
    /// [https://github.com/vincentlanglet/twig-cs-fixer](https://github.com/vincentlanglet/twig-cs-fixer)
    ///
    /// `twig-cs-fixer lint $PATH --no-interaction`
    TwigCsFixerLint,

    #[serde(rename = "twigcs")]
    /// The missing checkstyle for twig
    ///
    /// [https://github.com/friendsoftwig/twigcs](https://github.com/friendsoftwig/twigcs)
    ///
    /// `twigcs $PATH`
    Twigcs,

    #[serde(rename = "txtpbfmt")]
    /// txtpbfmt parses, edits and formats text proto files in a way that preserves comments
    ///
    /// [https://github.com/protocolbuffers/txtpbfmt](https://github.com/protocolbuffers/txtpbfmt)
    ///
    /// `txtpbfmt $PATH`
    Txtpbfmt,

    #[serde(rename = "ty")]
    /// An extremely fast Python type checker written in Rust
    ///
    /// [https://github.com/astral-sh/ty](https://github.com/astral-sh/ty)
    ///
    /// `ty check $PATH`
    Ty,

    #[serde(rename = "typos")]
    /// Source code spell checker
    ///
    /// [https://github.com/crate-ci/typos](https://github.com/crate-ci/typos)
    ///
    /// `typos -w --no-ignore --hidden $PATH`
    Typos,

    #[serde(rename = "typstfmt")]
    /// Basic formatter for the Typst language
    ///
    /// [https://github.com/astrale-sharp/typstfmt](https://github.com/astrale-sharp/typstfmt)
    ///
    /// `typstfmt $PATH`
    Typstfmt,

    #[serde(rename = "typstyle")]
    /// Beautiful and reliable typst code formatter
    ///
    /// [https://github.com/enter-tainer/typstyle](https://github.com/enter-tainer/typstyle)
    ///
    /// `typstyle -i $PATH`
    Typstyle,

    #[serde(rename = "ufmt")]
    /// Safe, atomic formatting with black and usort
    ///
    /// [https://github.com/omnilib/ufmt](https://github.com/omnilib/ufmt)
    ///
    /// `ufmt format $PATH`
    Ufmt,

    #[serde(rename = "uiua:fmt")]
    /// A stack-based array programming language
    ///
    /// [https://github.com/uiua-lang/uiua](https://github.com/uiua-lang/uiua)
    ///
    /// `uiua fmt $PATH`
    UiuaFmt,

    #[serde(rename = "unimport")]
    /// The ultimate linter and formatter for removing unused import statements in your code
    ///
    /// [https://github.com/hakancelikdev/unimport](https://github.com/hakancelikdev/unimport)
    ///
    /// `unimport -r $PATH`
    Unimport,

    #[serde(rename = "usort")]
    /// Safe, minimal import sorting for Python projects
    ///
    /// [https://github.com/facebook/usort](https://github.com/facebook/usort)
    ///
    /// `usort format $PATH`
    Usort,

    #[serde(rename = "v:fmt")]
    /// Format V code
    ///
    /// [https://docs.vlang.io/tools.html#v-fmt](https://docs.vlang.io/tools.html#v-fmt)
    ///
    /// `v fmt -w $PATH`
    VFmt,

    #[serde(rename = "vacuum:lint")]
    /// vacuum is the worlds fastest OpenAPI 3, OpenAPI 2 / Swagger linter and quality analysis tool
    ///
    /// [https://github.com/daveshanley/vacuum](https://github.com/daveshanley/vacuum)
    ///
    /// `vacuum lint $PATH`
    VacuumLint,

    #[serde(rename = "verusfmt")]
    /// An Opinionated Formatter for Verus
    ///
    /// [https://github.com/verus-lang/verusfmt](https://github.com/verus-lang/verusfmt)
    ///
    /// `verusfmt $PATH`
    Verusfmt,

    #[serde(rename = "veryl:fmt")]
    /// Format veryl code
    ///
    /// [https://doc.veryl-lang.org/book/06_development_environment/05_formatter.html](https://doc.veryl-lang.org/book/06_development_environment/05_formatter.html)
    ///
    /// `veryl fmt $PATH`
    VerylFmt,

    #[serde(rename = "vhdl-style-guide")]
    /// Style guide enforcement for VHDL
    ///
    /// [https://github.com/jeremiah-c-leary/vhdl-style-guide](https://github.com/jeremiah-c-leary/vhdl-style-guide)
    ///
    /// `vsg -f $PATH --fix`
    VhdlStyleGuide,

    #[serde(rename = "vint")]
    /// Fast and Highly Extensible Vim script Language Lint
    ///
    /// [https://github.com/vimjas/vint](https://github.com/vimjas/vint)
    ///
    /// `vint $PATH`
    Vint,

    #[serde(rename = "vint:neovim")]
    /// Fast and Highly Extensible Vim script Language Lint
    ///
    /// [https://github.com/vimjas/vint](https://github.com/vimjas/vint)
    ///
    /// `vint --enable-neovim $PATH`
    VintNeovim,

    #[serde(rename = "wa:fmt")]
    /// Format Wa source code
    ///
    /// [https://github.com/wa-lang/wa](https://github.com/wa-lang/wa)
    ///
    /// `wa fmt $PATH`
    WaFmt,

    #[serde(rename = "wfindent")]
    /// Indents and optionally converts Fortran program sources
    ///
    /// [https://github.com/wvermin/findent](https://github.com/wvermin/findent)
    ///
    /// `wfindent $PATH`
    Wfindent,

    #[serde(rename = "write-good")]
    /// Naive linter for English prose
    ///
    /// [https://github.com/btford/write-good](https://github.com/btford/write-good)
    ///
    /// `write-good $PATH`
    WriteGood,

    #[serde(rename = "xmlformat")]
    /// Format and compress XML documents
    ///
    /// [https://github.com/pamoller/xmlformatter](https://github.com/pamoller/xmlformatter)
    ///
    /// `xmlformat --overwrite $PATH`
    Xmlformat,

    #[serde(rename = "xmllint")]
    /// XML linter
    ///
    /// [https://gnome.pages.gitlab.gnome.org/libxml2/xmllint.html](https://gnome.pages.gitlab.gnome.org/libxml2/xmllint.html)
    ///
    /// `xmllint --format $PATH --output $PATH`
    Xmllint,

    #[serde(rename = "xo")]
    /// JavaScript/TypeScript linter (ESLint wrapper) with great defaults
    ///
    /// [https://github.com/xojs/xo](https://github.com/xojs/xo)
    ///
    /// `xo --fix --stdin`
    Xo,

    #[serde(rename = "xq")]
    /// Format XML
    ///
    /// [https://github.com/sibprogrammer/xq](https://github.com/sibprogrammer/xq)
    ///
    /// `xq`
    Xq,

    #[serde(rename = "xq:html")]
    /// Format HTML
    ///
    /// [https://github.com/sibprogrammer/xq](https://github.com/sibprogrammer/xq)
    ///
    /// `xq --html`
    XqHtml,

    #[serde(rename = "yamlfix")]
    /// A simple opinionated yaml formatter that keeps your comments
    ///
    /// [https://github.com/lyz-code/yamlfix](https://github.com/lyz-code/yamlfix)
    ///
    /// `yamlfix $PATH`
    Yamlfix,

    #[serde(rename = "yamlfmt")]
    /// An extensible command line tool or library to format yaml files
    ///
    /// [https://github.com/google/yamlfmt](https://github.com/google/yamlfmt)
    ///
    /// `yamlfmt -quiet $PATH`
    Yamlfmt,

    #[serde(rename = "yamllint")]
    /// A linter for YAML files
    ///
    /// [https://github.com/adrienverge/yamllint](https://github.com/adrienverge/yamllint)
    ///
    /// `yamllint $PATH`
    Yamllint,

    #[serde(rename = "yapf")]
    /// A formatter for Python files
    ///
    /// [https://github.com/google/yapf](https://github.com/google/yapf)
    ///
    /// `yapf --in-place $PATH`
    Yapf,

    #[serde(rename = "yard-lint")]
    /// Check your YARD docs like RuboCop checks your code - a linter for YARD documentation
    ///
    /// [https://github.com/mensfeld/yard-lint](https://github.com/mensfeld/yard-lint)
    ///
    /// `yard-lint $PATH`
    YardLint,

    #[serde(rename = "yew-fmt")]
    /// Code formatter for the Yew framework
    ///
    /// [https://github.com/its-the-shrimp/yew-fmt](https://github.com/its-the-shrimp/yew-fmt)
    ///
    /// `yew-fmt --edition 2021 $PATH`
    YewFmt,

    #[serde(rename = "yq")]
    /// yq is a portable command-line YAML, JSON, XML, CSV, TOML and properties processor
    ///
    /// [https://github.com/mikefarah/yq](https://github.com/mikefarah/yq)
    ///
    /// `yq --inplace $PATH`
    Yq,

    #[serde(rename = "zig:fmt")]
    /// Reformat Zig source into canonical form
    ///
    /// [https://ziglang.org](https://ziglang.org)
    ///
    /// `zig fmt $PATH`
    ZigFmt,

    #[serde(rename = "ziggy:check")]
    /// Checks Ziggy Documents for schema adherence
    ///
    /// [https://ziggy-lang.io/documentation/ziggy-check](https://ziggy-lang.io/documentation/ziggy-check)
    ///
    /// `ziggy check $PATH`
    ZiggyCheck,

    #[serde(rename = "ziggy:fmt")]
    /// Formats Ziggy documents and Ziggy schemas
    ///
    /// [https://ziggy-lang.io/documentation/ziggy-fmt](https://ziggy-lang.io/documentation/ziggy-fmt)
    ///
    /// `ziggy fmt $PATH`
    ZiggyFmt,

    #[serde(rename = "zprint")]
    /// Beautifully format Clojure and Clojurescript source code and s-expressions
    ///
    /// [https://github.com/kkinnear/zprint](https://github.com/kkinnear/zprint)
    ///
    /// `zprint -w $PATH`
    Zprint,

    #[serde(rename = "zsweep")]
    /// Linter for Zshell scripting language
    ///
    /// [https://github.com/psprint/zsh-sweep](https://github.com/psprint/zsh-sweep)
    ///
    /// `zsweep --auto $PATH`
    Zsweep,

    #[serde(rename = "zuban")]
    /// Python Type Checker
    ///
    /// [https://github.com/zubanls/zuban](https://github.com/zubanls/zuban)
    ///
    /// `zuban $PATH`
    Zuban,

    #[serde(rename = "zuban:check")]
    /// Python Type Checker
    ///
    /// [https://github.com/zubanls/zuban](https://github.com/zubanls/zuban)
    ///
    /// `zuban check $PATH`
    ZubanCheck,

    #[serde(rename = "zuban:mypy")]
    /// Python Type Checker
    ///
    /// [https://github.com/zubanls/zuban](https://github.com/zubanls/zuban)
    ///
    /// `zuban mypy $PATH`
    ZubanMypy,
}

impl Tooling {
    #[allow(clippy::too_many_lines)]
    #[inline]
    pub fn format_snippet(
        self,
        snippet_path: &std::path::Path,
        timeout: u64,
        debug_enabled: bool,
        config_runners: &crate::config::MdsfConfigRunners,
    ) -> Result<(bool, Option<String>), crate::error::MdsfError> {
        #[allow(clippy::type_complexity)]
        let (commands, set_args_fn, is_stdin): (
            &[crate::runners::CommandType],
            fn(std::process::Command, &std::path::Path) -> std::process::Command,
            bool,
        ) = match self {
            Self::ActionValidator => (
                &action_validator::COMMANDS,
                action_validator::set_args,
                action_validator::IS_STDIN,
            ),
            Self::Actionlint => (
                &actionlint::COMMANDS,
                actionlint::set_args,
                actionlint::IS_STDIN,
            ),
            Self::AirFormat => (
                &air_format::COMMANDS,
                air_format::set_args,
                air_format::IS_STDIN,
            ),
            Self::Alejandra => (
                &alejandra::COMMANDS,
                alejandra::set_args,
                alejandra::IS_STDIN,
            ),
            Self::Alex => (&alex::COMMANDS, alex::set_args, alex::IS_STDIN),
            Self::Ameba => (&ameba::COMMANDS, ameba::set_args, ameba::IS_STDIN),
            Self::AnsibleLint => (
                &ansible_lint::COMMANDS,
                ansible_lint::set_args,
                ansible_lint::IS_STDIN,
            ),
            Self::ApiLinter => (
                &api_linter::COMMANDS,
                api_linter::set_args,
                api_linter::IS_STDIN,
            ),
            Self::Asmfmt => (&asmfmt::COMMANDS, asmfmt::set_args, asmfmt::IS_STDIN),
            Self::Astyle => (&astyle::COMMANDS, astyle::set_args, astyle::IS_STDIN),
            Self::AtlasFmt => (
                &atlas_fmt::COMMANDS,
                atlas_fmt::set_args,
                atlas_fmt::IS_STDIN,
            ),
            Self::AtlasLint => (
                &atlas_lint::COMMANDS,
                atlas_lint::set_args,
                atlas_lint::IS_STDIN,
            ),
            Self::AutoOptional => (
                &auto_optional::COMMANDS,
                auto_optional::set_args,
                auto_optional::IS_STDIN,
            ),
            Self::Autocorrect => (
                &autocorrect::COMMANDS,
                autocorrect::set_args,
                autocorrect::IS_STDIN,
            ),
            Self::Autoflake => (
                &autoflake::COMMANDS,
                autoflake::set_args,
                autoflake::IS_STDIN,
            ),
            Self::Autopep8 => (
                &autopep_8::COMMANDS,
                autopep_8::set_args,
                autopep_8::IS_STDIN,
            ),
            Self::Bashate => (&bashate::COMMANDS, bashate::set_args, bashate::IS_STDIN),
            Self::BeancountBlack => (
                &beancount_black::COMMANDS,
                beancount_black::set_args,
                beancount_black::IS_STDIN,
            ),
            Self::Beautysh => (&beautysh::COMMANDS, beautysh::set_args, beautysh::IS_STDIN),
            Self::BibtexTidy => (
                &bibtex_tidy::COMMANDS,
                bibtex_tidy::set_args,
                bibtex_tidy::IS_STDIN,
            ),
            Self::BicepFormat => (
                &bicep_format::COMMANDS,
                bicep_format::set_args,
                bicep_format::IS_STDIN,
            ),
            Self::BiomeCheck => (
                &biome_check::COMMANDS,
                biome_check::set_args,
                biome_check::IS_STDIN,
            ),
            Self::BiomeCheckUnsafe => (
                &biome_check_unsafe::COMMANDS,
                biome_check_unsafe::set_args,
                biome_check_unsafe::IS_STDIN,
            ),
            Self::BiomeFormat => (
                &biome_format::COMMANDS,
                biome_format::set_args,
                biome_format::IS_STDIN,
            ),
            Self::BiomeLint => (
                &biome_lint::COMMANDS,
                biome_lint::set_args,
                biome_lint::IS_STDIN,
            ),
            Self::BiomeLintUnsafe => (
                &biome_lint_unsafe::COMMANDS,
                biome_lint_unsafe::set_args,
                biome_lint_unsafe::IS_STDIN,
            ),
            Self::Black => (&black::COMMANDS, black::set_args, black::IS_STDIN),
            Self::BladeFormatter => (
                &blade_formatter::COMMANDS,
                blade_formatter::set_args,
                blade_formatter::IS_STDIN,
            ),
            Self::Blue => (&blue::COMMANDS, blue::set_args, blue::IS_STDIN),
            Self::Bpfmt => (&bpfmt::COMMANDS, bpfmt::set_args, bpfmt::IS_STDIN),
            Self::Brittany => (&brittany::COMMANDS, brittany::set_args, brittany::IS_STDIN),
            Self::Brunette => (&brunette::COMMANDS, brunette::set_args, brunette::IS_STDIN),
            Self::Bsfmt => (&bsfmt::COMMANDS, bsfmt::set_args, bsfmt::IS_STDIN),
            Self::Bslint => (&bslint::COMMANDS, bslint::set_args, bslint::IS_STDIN),
            Self::BufFormat => (
                &buf_format::COMMANDS,
                buf_format::set_args,
                buf_format::IS_STDIN,
            ),
            Self::BufLint => (&buf_lint::COMMANDS, buf_lint::set_args, buf_lint::IS_STDIN),
            Self::Buildifier => (
                &buildifier::COMMANDS,
                buildifier::set_args,
                buildifier::IS_STDIN,
            ),
            Self::CabalFmt => (
                &cabal_fmt::COMMANDS,
                cabal_fmt::set_args,
                cabal_fmt::IS_STDIN,
            ),
            Self::CabalFormat => (
                &cabal_format::COMMANDS,
                cabal_format::set_args,
                cabal_format::IS_STDIN,
            ),
            Self::CabalGild => (
                &cabal_gild::COMMANDS,
                cabal_gild::set_args,
                cabal_gild::IS_STDIN,
            ),
            Self::CabalPrettify => (
                &cabal_prettify::COMMANDS,
                cabal_prettify::set_args,
                cabal_prettify::IS_STDIN,
            ),
            Self::CaddyFmt => (
                &caddy_fmt::COMMANDS,
                caddy_fmt::set_args,
                caddy_fmt::IS_STDIN,
            ),
            Self::CaramelFmt => (
                &caramel_fmt::COMMANDS,
                caramel_fmt::set_args,
                caramel_fmt::IS_STDIN,
            ),
            Self::CedarFormat => (
                &cedar_format::COMMANDS,
                cedar_format::set_args,
                cedar_format::IS_STDIN,
            ),
            Self::CfnLint => (&cfn_lint::COMMANDS, cfn_lint::set_args, cfn_lint::IS_STDIN),
            Self::Checkmake => (
                &checkmake::COMMANDS,
                checkmake::set_args,
                checkmake::IS_STDIN,
            ),
            Self::ClangFormat => (
                &clang_format::COMMANDS,
                clang_format::set_args,
                clang_format::IS_STDIN,
            ),
            Self::ClangTidy => (
                &clang_tidy::COMMANDS,
                clang_tidy::set_args,
                clang_tidy::IS_STDIN,
            ),
            Self::CljKondo => (
                &clj_kondo::COMMANDS,
                clj_kondo::set_args,
                clj_kondo::IS_STDIN,
            ),
            Self::CljfmtFix => (
                &cljfmt_fix::COMMANDS,
                cljfmt_fix::set_args,
                cljfmt_fix::IS_STDIN,
            ),
            Self::Cljstyle => (&cljstyle::COMMANDS, cljstyle::set_args, cljstyle::IS_STDIN),
            Self::CmakeFormat => (
                &cmake_format::COMMANDS,
                cmake_format::set_args,
                cmake_format::IS_STDIN,
            ),
            Self::CmakeLint => (
                &cmake_lint::COMMANDS,
                cmake_lint::set_args,
                cmake_lint::IS_STDIN,
            ),
            Self::CodeqlQueryFormat => (
                &codeql_query_format::COMMANDS,
                codeql_query_format::set_args,
                codeql_query_format::IS_STDIN,
            ),
            Self::Codespell => (
                &codespell::COMMANDS,
                codespell::set_args,
                codespell::IS_STDIN,
            ),
            Self::Coffeelint => (
                &coffeelint::COMMANDS,
                coffeelint::set_args,
                coffeelint::IS_STDIN,
            ),
            Self::Cppcheck => (&cppcheck::COMMANDS, cppcheck::set_args, cppcheck::IS_STDIN),
            Self::Cpplint => (&cpplint::COMMANDS, cpplint::set_args, cpplint::IS_STDIN),
            Self::Crlfmt => (&crlfmt::COMMANDS, crlfmt::set_args, crlfmt::IS_STDIN),
            Self::CrystalFormat => (
                &crystal_format::COMMANDS,
                crystal_format::set_args,
                crystal_format::IS_STDIN,
            ),
            Self::Csharpier => (
                &csharpier::COMMANDS,
                csharpier::set_args,
                csharpier::IS_STDIN,
            ),
            Self::CssBeautify => (
                &css_beautify::COMMANDS,
                css_beautify::set_args,
                css_beautify::IS_STDIN,
            ),
            Self::Csscomb => (&csscomb::COMMANDS, csscomb::set_args, csscomb::IS_STDIN),
            Self::Csslint => (&csslint::COMMANDS, csslint::set_args, csslint::IS_STDIN),
            Self::CueFmt => (&cue_fmt::COMMANDS, cue_fmt::set_args, cue_fmt::IS_STDIN),
            Self::Cueimports => (
                &cueimports::COMMANDS,
                cueimports::set_args,
                cueimports::IS_STDIN,
            ),
            Self::Curlylint => (
                &curlylint::COMMANDS,
                curlylint::set_args,
                curlylint::IS_STDIN,
            ),
            Self::D2Fmt => (&d_2_fmt::COMMANDS, d_2_fmt::set_args, d_2_fmt::IS_STDIN),
            Self::DartFix => (&dart_fix::COMMANDS, dart_fix::set_args, dart_fix::IS_STDIN),
            Self::DartFormat => (
                &dart_format::COMMANDS,
                dart_format::set_args,
                dart_format::IS_STDIN,
            ),
            Self::DcmFix => (&dcm_fix::COMMANDS, dcm_fix::set_args, dcm_fix::IS_STDIN),
            Self::DcmFormat => (
                &dcm_format::COMMANDS,
                dcm_format::set_args,
                dcm_format::IS_STDIN,
            ),
            Self::Deadnix => (&deadnix::COMMANDS, deadnix::set_args, deadnix::IS_STDIN),
            Self::DenoFmt => (&deno_fmt::COMMANDS, deno_fmt::set_args, deno_fmt::IS_STDIN),
            Self::DenoLint => (
                &deno_lint::COMMANDS,
                deno_lint::set_args,
                deno_lint::IS_STDIN,
            ),
            Self::Dfmt => (&dfmt::COMMANDS, dfmt::set_args, dfmt::IS_STDIN),
            Self::DhallFormat => (
                &dhall_format::COMMANDS,
                dhall_format::set_args,
                dhall_format::IS_STDIN,
            ),
            Self::DhallLint => (
                &dhall_lint::COMMANDS,
                dhall_lint::set_args,
                dhall_lint::IS_STDIN,
            ),
            Self::Djade => (&djade::COMMANDS, djade::set_args, djade::IS_STDIN),
            Self::Djlint => (&djlint::COMMANDS, djlint::set_args, djlint::IS_STDIN),
            Self::Docformatter => (
                &docformatter::COMMANDS,
                docformatter::set_args,
                docformatter::IS_STDIN,
            ),
            Self::Dockerfmt => (
                &dockerfmt::COMMANDS,
                dockerfmt::set_args,
                dockerfmt::IS_STDIN,
            ),
            Self::Dockfmt => (&dockfmt::COMMANDS, dockfmt::set_args, dockfmt::IS_STDIN),
            Self::Docstrfmt => (
                &docstrfmt::COMMANDS,
                docstrfmt::set_args,
                docstrfmt::IS_STDIN,
            ),
            Self::Doctoc => (&doctoc::COMMANDS, doctoc::set_args, doctoc::IS_STDIN),
            Self::DotenvLinterFix => (
                &dotenv_linter_fix::COMMANDS,
                dotenv_linter_fix::set_args,
                dotenv_linter_fix::IS_STDIN,
            ),
            Self::DprintFmt => (
                &dprint_fmt::COMMANDS,
                dprint_fmt::set_args,
                dprint_fmt::IS_STDIN,
            ),
            Self::DscannerFix => (
                &dscanner_fix::COMMANDS,
                dscanner_fix::set_args,
                dscanner_fix::IS_STDIN,
            ),
            Self::DscannerLint => (
                &dscanner_lint::COMMANDS,
                dscanner_lint::set_args,
                dscanner_lint::IS_STDIN,
            ),
            Self::DuneFormatDuneFile => (
                &dune_format_dune_file::COMMANDS,
                dune_format_dune_file::set_args,
                dune_format_dune_file::IS_STDIN,
            ),
            Self::DusterFix => (
                &duster_fix::COMMANDS,
                duster_fix::set_args,
                duster_fix::IS_STDIN,
            ),
            Self::DusterLint => (
                &duster_lint::COMMANDS,
                duster_lint::set_args,
                duster_lint::IS_STDIN,
            ),
            Self::DxFmt => (&dx_fmt::COMMANDS, dx_fmt::set_args, dx_fmt::IS_STDIN),
            Self::EasyCodingStandard => (
                &easy_coding_standard::COMMANDS,
                easy_coding_standard::set_args,
                easy_coding_standard::IS_STDIN,
            ),
            Self::Efmt => (&efmt::COMMANDS, efmt::set_args, efmt::IS_STDIN),
            Self::ElmFormat => (
                &elm_format::COMMANDS,
                elm_format::set_args,
                elm_format::IS_STDIN,
            ),
            Self::Eradicate => (
                &eradicate::COMMANDS,
                eradicate::set_args,
                eradicate::IS_STDIN,
            ),
            Self::ErbFormatter => (
                &erb_formatter::COMMANDS,
                erb_formatter::set_args,
                erb_formatter::IS_STDIN,
            ),
            Self::ErgLint => (&erg_lint::COMMANDS, erg_lint::set_args, erg_lint::IS_STDIN),
            Self::Erlfmt => (&erlfmt::COMMANDS, erlfmt::set_args, erlfmt::IS_STDIN),
            Self::Eslint => (&eslint::COMMANDS, eslint::set_args, eslint::IS_STDIN),
            Self::Fantomas => (&fantomas::COMMANDS, fantomas::set_args, fantomas::IS_STDIN),
            Self::FishIndent => (
                &fish_indent::COMMANDS,
                fish_indent::set_args,
                fish_indent::IS_STDIN,
            ),
            Self::Fixjson => (&fixjson::COMMANDS, fixjson::set_args, fixjson::IS_STDIN),
            Self::Floskell => (&floskell::COMMANDS, floskell::set_args, floskell::IS_STDIN),
            Self::Flynt => (&flynt::COMMANDS, flynt::set_args, flynt::IS_STDIN),
            Self::Fnlfmt => (&fnlfmt::COMMANDS, fnlfmt::set_args, fnlfmt::IS_STDIN),
            Self::ForgeFmt => (
                &forge_fmt::COMMANDS,
                forge_fmt::set_args,
                forge_fmt::IS_STDIN,
            ),
            Self::FortitudeCheck => (
                &fortitude_check::COMMANDS,
                fortitude_check::set_args,
                fortitude_check::IS_STDIN,
            ),
            Self::FortitudeCheckFix => (
                &fortitude_check_fix::COMMANDS,
                fortitude_check_fix::set_args,
                fortitude_check_fix::IS_STDIN,
            ),
            Self::FortitudeCheckFixUnsafe => (
                &fortitude_check_fix_unsafe::COMMANDS,
                fortitude_check_fix_unsafe::set_args,
                fortitude_check_fix_unsafe::IS_STDIN,
            ),
            Self::FortranLinter => (
                &fortran_linter::COMMANDS,
                fortran_linter::set_args,
                fortran_linter::IS_STDIN,
            ),
            Self::Fourmolu => (&fourmolu::COMMANDS, fourmolu::set_args, fourmolu::IS_STDIN),
            Self::Fprettify => (
                &fprettify::COMMANDS,
                fprettify::set_args,
                fprettify::IS_STDIN,
            ),
            Self::FutharkFmt => (
                &futhark_fmt::COMMANDS,
                futhark_fmt::set_args,
                futhark_fmt::IS_STDIN,
            ),
            Self::FvmDartFix => (
                &fvm_dart_fix::COMMANDS,
                fvm_dart_fix::set_args,
                fvm_dart_fix::IS_STDIN,
            ),
            Self::FvmDartFormat => (
                &fvm_dart_format::COMMANDS,
                fvm_dart_format::set_args,
                fvm_dart_format::IS_STDIN,
            ),
            Self::Gci => (&gci::COMMANDS, gci::set_args, gci::IS_STDIN),
            Self::Gdformat => (&gdformat::COMMANDS, gdformat::set_args, gdformat::IS_STDIN),
            Self::Gdlint => (&gdlint::COMMANDS, gdlint::set_args, gdlint::IS_STDIN),
            Self::Gersemi => (&gersemi::COMMANDS, gersemi::set_args, gersemi::IS_STDIN),
            Self::GhokinCheck => (
                &ghokin_check::COMMANDS,
                ghokin_check::set_args,
                ghokin_check::IS_STDIN,
            ),
            Self::GhokinFmt => (
                &ghokin_fmt::COMMANDS,
                ghokin_fmt::set_args,
                ghokin_fmt::IS_STDIN,
            ),
            Self::GleamFormat => (
                &gleam_format::COMMANDS,
                gleam_format::set_args,
                gleam_format::IS_STDIN,
            ),
            Self::GluonFmt => (
                &gluon_fmt::COMMANDS,
                gluon_fmt::set_args,
                gluon_fmt::IS_STDIN,
            ),
            Self::Gofmt => (&gofmt::COMMANDS, gofmt::set_args, gofmt::IS_STDIN),
            Self::Gofumpt => (&gofumpt::COMMANDS, gofumpt::set_args, gofumpt::IS_STDIN),
            Self::Goimports => (
                &goimports::COMMANDS,
                goimports::set_args,
                goimports::IS_STDIN,
            ),
            Self::GoimportsReviser => (
                &goimports_reviser::COMMANDS,
                goimports_reviser::set_args,
                goimports_reviser::IS_STDIN,
            ),
            Self::GolangciLintFmt => (
                &golangci_lint_fmt::COMMANDS,
                golangci_lint_fmt::set_args,
                golangci_lint_fmt::IS_STDIN,
            ),
            Self::GolangciLintRun => (
                &golangci_lint_run::COMMANDS,
                golangci_lint_run::set_args,
                golangci_lint_run::IS_STDIN,
            ),
            Self::GolangciLintRunFix => (
                &golangci_lint_run_fix::COMMANDS,
                golangci_lint_run_fix::set_args,
                golangci_lint_run_fix::IS_STDIN,
            ),
            Self::Golines => (&golines::COMMANDS, golines::set_args, golines::IS_STDIN),
            Self::GoogleJavaFormat => (
                &google_java_format::COMMANDS,
                google_java_format::set_args,
                google_java_format::IS_STDIN,
            ),
            Self::Gospel => (&gospel::COMMANDS, gospel::set_args, gospel::IS_STDIN),
            Self::GrafbaseLint => (
                &grafbase_lint::COMMANDS,
                grafbase_lint::set_args,
                grafbase_lint::IS_STDIN,
            ),
            Self::GrainFormat => (
                &grain_format::COMMANDS,
                grain_format::set_args,
                grain_format::IS_STDIN,
            ),
            Self::Hadolint => (&hadolint::COMMANDS, hadolint::set_args, hadolint::IS_STDIN),
            Self::HamlLint => (
                &haml_lint::COMMANDS,
                haml_lint::set_args,
                haml_lint::IS_STDIN,
            ),
            Self::Hclfmt => (&hclfmt::COMMANDS, hclfmt::set_args, hclfmt::IS_STDIN),
            Self::Hfmt => (&hfmt::COMMANDS, hfmt::set_args, hfmt::IS_STDIN),
            Self::Hindent => (&hindent::COMMANDS, hindent::set_args, hindent::IS_STDIN),
            Self::Hlint => (&hlint::COMMANDS, hlint::set_args, hlint::IS_STDIN),
            Self::HtmlBeautify => (
                &html_beautify::COMMANDS,
                html_beautify::set_args,
                html_beautify::IS_STDIN,
            ),
            Self::Htmlbeautifier => (
                &htmlbeautifier::COMMANDS,
                htmlbeautifier::set_args,
                htmlbeautifier::IS_STDIN,
            ),
            Self::Htmlhint => (&htmlhint::COMMANDS, htmlhint::set_args, htmlhint::IS_STDIN),
            Self::Hurlfmt => (&hurlfmt::COMMANDS, hurlfmt::set_args, hurlfmt::IS_STDIN),
            Self::ImbaFmt => (&imba_fmt::COMMANDS, imba_fmt::set_args, imba_fmt::IS_STDIN),
            Self::InkoFmt => (&inko_fmt::COMMANDS, inko_fmt::set_args, inko_fmt::IS_STDIN),
            Self::Isort => (&isort::COMMANDS, isort::set_args, isort::IS_STDIN),
            Self::JanetFormat => (
                &janet_format::COMMANDS,
                janet_format::set_args,
                janet_format::IS_STDIN,
            ),
            Self::Joker => (&joker::COMMANDS, joker::set_args, joker::IS_STDIN),
            Self::Jq => (&jq::COMMANDS, jq::set_args, jq::IS_STDIN),
            Self::Jqfmt => (&jqfmt::COMMANDS, jqfmt::set_args, jqfmt::IS_STDIN),
            Self::JsBeautify => (
                &js_beautify::COMMANDS,
                js_beautify::set_args,
                js_beautify::IS_STDIN,
            ),
            Self::Json5Format => (
                &json_5_format::COMMANDS,
                json_5_format::set_args,
                json_5_format::IS_STDIN,
            ),
            Self::JsonRepair => (
                &json_repair::COMMANDS,
                json_repair::set_args,
                json_repair::IS_STDIN,
            ),
            Self::JsonaFormat => (
                &jsona_format::COMMANDS,
                jsona_format::set_args,
                jsona_format::IS_STDIN,
            ),
            Self::JsonaLint => (
                &jsona_lint::COMMANDS,
                jsona_lint::set_args,
                jsona_lint::IS_STDIN,
            ),
            Self::Jsonlint => (&jsonlint::COMMANDS, jsonlint::set_args, jsonlint::IS_STDIN),
            Self::JsonlintSort => (
                &jsonlint_sort::COMMANDS,
                jsonlint_sort::set_args,
                jsonlint_sort::IS_STDIN,
            ),
            Self::JsonnetLint => (
                &jsonnet_lint::COMMANDS,
                jsonnet_lint::set_args,
                jsonnet_lint::IS_STDIN,
            ),
            Self::Jsonnetfmt => (
                &jsonnetfmt::COMMANDS,
                jsonnetfmt::set_args,
                jsonnetfmt::IS_STDIN,
            ),
            Self::Jsonpp => (&jsonpp::COMMANDS, jsonpp::set_args, jsonpp::IS_STDIN),
            Self::JuliaformatterJl => (
                &juliaformatter_jl::COMMANDS,
                juliaformatter_jl::set_args,
                juliaformatter_jl::IS_STDIN,
            ),
            Self::Just => (&just::COMMANDS, just::set_args, just::IS_STDIN),
            Self::KclFmt => (&kcl_fmt::COMMANDS, kcl_fmt::set_args, kcl_fmt::IS_STDIN),
            Self::KclLint => (&kcl_lint::COMMANDS, kcl_lint::set_args, kcl_lint::IS_STDIN),
            Self::Kdlfmt => (&kdlfmt::COMMANDS, kdlfmt::set_args, kdlfmt::IS_STDIN),
            Self::KdlfmtV1 => (
                &kdlfmt_v_1::COMMANDS,
                kdlfmt_v_1::set_args,
                kdlfmt_v_1::IS_STDIN,
            ),
            Self::KdlfmtV2 => (
                &kdlfmt_v_2::COMMANDS,
                kdlfmt_v_2::set_args,
                kdlfmt_v_2::IS_STDIN,
            ),
            Self::KdocFormatter => (
                &kdoc_formatter::COMMANDS,
                kdoc_formatter::set_args,
                kdoc_formatter::IS_STDIN,
            ),
            Self::KeepSorted => (
                &keep_sorted::COMMANDS,
                keep_sorted::set_args,
                keep_sorted::IS_STDIN,
            ),
            Self::Ktfmt => (&ktfmt::COMMANDS, ktfmt::set_args, ktfmt::IS_STDIN),
            Self::Ktlint => (&ktlint::COMMANDS, ktlint::set_args, ktlint::IS_STDIN),
            Self::KubeLinterLint => (
                &kube_linter_lint::COMMANDS,
                kube_linter_lint::set_args,
                kube_linter_lint::IS_STDIN,
            ),
            Self::KulalaFmtCheck => (
                &kulala_fmt_check::COMMANDS,
                kulala_fmt_check::set_args,
                kulala_fmt_check::IS_STDIN,
            ),
            Self::KulalaFmtFormat => (
                &kulala_fmt_format::COMMANDS,
                kulala_fmt_format::set_args,
                kulala_fmt_format::IS_STDIN,
            ),
            Self::Leptosfmt => (
                &leptosfmt::COMMANDS,
                leptosfmt::set_args,
                leptosfmt::IS_STDIN,
            ),
            Self::LiquidsoapPrettier => (
                &liquidsoap_prettier::COMMANDS,
                liquidsoap_prettier::set_args,
                liquidsoap_prettier::IS_STDIN,
            ),
            Self::Luacheck => (&luacheck::COMMANDS, luacheck::set_args, luacheck::IS_STDIN),
            Self::Luaformatter => (
                &luaformatter::COMMANDS,
                luaformatter::set_args,
                luaformatter::IS_STDIN,
            ),
            Self::LuauAnalyze => (
                &luau_analyze::COMMANDS,
                luau_analyze::set_args,
                luau_analyze::IS_STDIN,
            ),
            Self::MadoCheck => (
                &mado_check::COMMANDS,
                mado_check::set_args,
                mado_check::IS_STDIN,
            ),
            Self::MagoAnalyze => (
                &mago_analyze::COMMANDS,
                mago_analyze::set_args,
                mago_analyze::IS_STDIN,
            ),
            Self::MagoAnalyzeFix => (
                &mago_analyze_fix::COMMANDS,
                mago_analyze_fix::set_args,
                mago_analyze_fix::IS_STDIN,
            ),
            Self::MagoAnalyzeFixUnsafe => (
                &mago_analyze_fix_unsafe::COMMANDS,
                mago_analyze_fix_unsafe::set_args,
                mago_analyze_fix_unsafe::IS_STDIN,
            ),
            Self::MagoFormat => (
                &mago_format::COMMANDS,
                mago_format::set_args,
                mago_format::IS_STDIN,
            ),
            Self::MagoLint => (
                &mago_lint::COMMANDS,
                mago_lint::set_args,
                mago_lint::IS_STDIN,
            ),
            Self::MagoLintFix => (
                &mago_lint_fix::COMMANDS,
                mago_lint_fix::set_args,
                mago_lint_fix::IS_STDIN,
            ),
            Self::MagoLintFixUnsafe => (
                &mago_lint_fix_unsafe::COMMANDS,
                mago_lint_fix_unsafe::set_args,
                mago_lint_fix_unsafe::IS_STDIN,
            ),
            Self::Markdownfmt => (
                &markdownfmt::COMMANDS,
                markdownfmt::set_args,
                markdownfmt::IS_STDIN,
            ),
            Self::Markdownlint => (
                &markdownlint::COMMANDS,
                markdownlint::set_args,
                markdownlint::IS_STDIN,
            ),
            Self::MarkdownlintCli2 => (
                &markdownlint_cli_2::COMMANDS,
                markdownlint_cli_2::set_args,
                markdownlint_cli_2::IS_STDIN,
            ),
            Self::Markuplint => (
                &markuplint::COMMANDS,
                markuplint::set_args,
                markuplint::IS_STDIN,
            ),
            Self::MbakeFormat => (
                &mbake_format::COMMANDS,
                mbake_format::set_args,
                mbake_format::IS_STDIN,
            ),
            Self::MbakeValidate => (
                &mbake_validate::COMMANDS,
                mbake_validate::set_args,
                mbake_validate::IS_STDIN,
            ),
            Self::MdPadding => (
                &md_padding::COMMANDS,
                md_padding::set_args,
                md_padding::IS_STDIN,
            ),
            Self::Mdformat => (&mdformat::COMMANDS, mdformat::set_args, mdformat::IS_STDIN),
            Self::MdsfFormat => (
                &mdsf_format::COMMANDS,
                mdsf_format::set_args,
                mdsf_format::IS_STDIN,
            ),
            Self::MdsfVerify => (
                &mdsf_verify::COMMANDS,
                mdsf_verify::set_args,
                mdsf_verify::IS_STDIN,
            ),
            Self::Mdslw => (&mdslw::COMMANDS, mdslw::set_args, mdslw::IS_STDIN),
            Self::MesonFmt => (
                &meson_fmt::COMMANDS,
                meson_fmt::set_args,
                meson_fmt::IS_STDIN,
            ),
            Self::MhLint => (&mh_lint::COMMANDS, mh_lint::set_args, mh_lint::IS_STDIN),
            Self::MhStyle => (&mh_style::COMMANDS, mh_style::set_args, mh_style::IS_STDIN),
            Self::MiseFmt => (&mise_fmt::COMMANDS, mise_fmt::set_args, mise_fmt::IS_STDIN),
            Self::Misspell => (&misspell::COMMANDS, misspell::set_args, misspell::IS_STDIN),
            Self::MixFormat => (
                &mix_format::COMMANDS,
                mix_format::set_args,
                mix_format::IS_STDIN,
            ),
            Self::MojoFormat => (
                &mojo_format::COMMANDS,
                mojo_format::set_args,
                mojo_format::IS_STDIN,
            ),
            Self::MuonFmt => (&muon_fmt::COMMANDS, muon_fmt::set_args, muon_fmt::IS_STDIN),
            Self::MuonLint => (
                &muon_lint::COMMANDS,
                muon_lint::set_args,
                muon_lint::IS_STDIN,
            ),
            Self::Mypy => (&mypy::COMMANDS, mypy::set_args, mypy::IS_STDIN),
            Self::Nasmfmt => (&nasmfmt::COMMANDS, nasmfmt::set_args, nasmfmt::IS_STDIN),
            Self::Nginxbeautifier => (
                &nginxbeautifier::COMMANDS,
                nginxbeautifier::set_args,
                nginxbeautifier::IS_STDIN,
            ),
            Self::Nginxfmt => (&nginxfmt::COMMANDS, nginxfmt::set_args, nginxfmt::IS_STDIN),
            Self::NickelFormat => (
                &nickel_format::COMMANDS,
                nickel_format::set_args,
                nickel_format::IS_STDIN,
            ),
            Self::Nimpretty => (
                &nimpretty::COMMANDS,
                nimpretty::set_args,
                nimpretty::IS_STDIN,
            ),
            Self::Nixfmt => (&nixfmt::COMMANDS, nixfmt::set_args, nixfmt::IS_STDIN),
            Self::NixpkgsFmt => (
                &nixpkgs_fmt::COMMANDS,
                nixpkgs_fmt::set_args,
                nixpkgs_fmt::IS_STDIN,
            ),
            Self::NomadFmt => (
                &nomad_fmt::COMMANDS,
                nomad_fmt::set_args,
                nomad_fmt::IS_STDIN,
            ),
            Self::Nph => (&nph::COMMANDS, nph::set_args, nph::IS_STDIN),
            Self::NpmGroovyLint => (
                &npm_groovy_lint::COMMANDS,
                npm_groovy_lint::set_args,
                npm_groovy_lint::IS_STDIN,
            ),
            Self::Nufmt => (&nufmt::COMMANDS, nufmt::set_args, nufmt::IS_STDIN),
            Self::Ocamlformat => (
                &ocamlformat::COMMANDS,
                ocamlformat::set_args,
                ocamlformat::IS_STDIN,
            ),
            Self::OcpIndent => (
                &ocp_indent::COMMANDS,
                ocp_indent::set_args,
                ocp_indent::IS_STDIN,
            ),
            Self::Odinfmt => (&odinfmt::COMMANDS, odinfmt::set_args, odinfmt::IS_STDIN),
            Self::OelintAdv => (
                &oelint_adv::COMMANDS,
                oelint_adv::set_args,
                oelint_adv::IS_STDIN,
            ),
            Self::OpaFmt => (&opa_fmt::COMMANDS, opa_fmt::set_args, opa_fmt::IS_STDIN),
            Self::Ormolu => (&ormolu::COMMANDS, ormolu::set_args, ormolu::IS_STDIN),
            Self::Oxfmt => (&oxfmt::COMMANDS, oxfmt::set_args, oxfmt::IS_STDIN),
            Self::Oxlint => (&oxlint::COMMANDS, oxlint::set_args, oxlint::IS_STDIN),
            Self::PackerFix => (
                &packer_fix::COMMANDS,
                packer_fix::set_args,
                packer_fix::IS_STDIN,
            ),
            Self::PackerFmt => (
                &packer_fmt::COMMANDS,
                packer_fmt::set_args,
                packer_fmt::IS_STDIN,
            ),
            Self::PackerValidate => (
                &packer_validate::COMMANDS,
                packer_validate::set_args,
                packer_validate::IS_STDIN,
            ),
            Self::Pasfmt => (&pasfmt::COMMANDS, pasfmt::set_args, pasfmt::IS_STDIN),
            Self::Perflint => (&perflint::COMMANDS, perflint::set_args, perflint::IS_STDIN),
            Self::Perltidy => (&perltidy::COMMANDS, perltidy::set_args, perltidy::IS_STDIN),
            Self::PgFormat => (
                &pg_format::COMMANDS,
                pg_format::set_args,
                pg_format::IS_STDIN,
            ),
            Self::PhpCsFixerFix => (
                &php_cs_fixer_fix::COMMANDS,
                php_cs_fixer_fix::set_args,
                php_cs_fixer_fix::IS_STDIN,
            ),
            Self::Phpcbf => (&phpcbf::COMMANDS, phpcbf::set_args, phpcbf::IS_STDIN),
            Self::PhpinsightsFix => (
                &phpinsights_fix::COMMANDS,
                phpinsights_fix::set_args,
                phpinsights_fix::IS_STDIN,
            ),
            Self::Pint => (&pint::COMMANDS, pint::set_args, pint::IS_STDIN),
            Self::PklFormat => (
                &pkl_format::COMMANDS,
                pkl_format::set_args,
                pkl_format::IS_STDIN,
            ),
            Self::Prettier => (&prettier::COMMANDS, prettier::set_args, prettier::IS_STDIN),
            Self::Prettierd => (
                &prettierd::COMMANDS,
                prettierd::set_args,
                prettierd::IS_STDIN,
            ),
            Self::PrettyPhp => (
                &pretty_php::COMMANDS,
                pretty_php::set_args,
                pretty_php::IS_STDIN,
            ),
            Self::Prettypst => (
                &prettypst::COMMANDS,
                prettypst::set_args,
                prettypst::IS_STDIN,
            ),
            Self::PrismaFormat => (
                &prisma_format::COMMANDS,
                prisma_format::set_args,
                prisma_format::IS_STDIN,
            ),
            Self::Proselint => (
                &proselint::COMMANDS,
                proselint::set_args,
                proselint::IS_STDIN,
            ),
            Self::Protolint => (
                &protolint::COMMANDS,
                protolint::set_args,
                protolint::IS_STDIN,
            ),
            Self::Ptop => (&ptop::COMMANDS, ptop::set_args, ptop::IS_STDIN),
            Self::PugLint => (&pug_lint::COMMANDS, pug_lint::set_args, pug_lint::IS_STDIN),
            Self::PuppetLint => (
                &puppet_lint::COMMANDS,
                puppet_lint::set_args,
                puppet_lint::IS_STDIN,
            ),
            Self::PursTidy => (
                &purs_tidy::COMMANDS,
                purs_tidy::set_args,
                purs_tidy::IS_STDIN,
            ),
            Self::Purty => (&purty::COMMANDS, purty::set_args, purty::IS_STDIN),
            Self::Pycln => (&pycln::COMMANDS, pycln::set_args, pycln::IS_STDIN),
            Self::Pycodestyle => (
                &pycodestyle::COMMANDS,
                pycodestyle::set_args,
                pycodestyle::IS_STDIN,
            ),
            Self::Pydoclint => (
                &pydoclint::COMMANDS,
                pydoclint::set_args,
                pydoclint::IS_STDIN,
            ),
            Self::Pydocstringformatter => (
                &pydocstringformatter::COMMANDS,
                pydocstringformatter::set_args,
                pydocstringformatter::IS_STDIN,
            ),
            Self::Pydocstyle => (
                &pydocstyle::COMMANDS,
                pydocstyle::set_args,
                pydocstyle::IS_STDIN,
            ),
            Self::Pyflakes => (&pyflakes::COMMANDS, pyflakes::set_args, pyflakes::IS_STDIN),
            Self::Pyink => (&pyink::COMMANDS, pyink::set_args, pyink::IS_STDIN),
            Self::Pylint => (&pylint::COMMANDS, pylint::set_args, pylint::IS_STDIN),
            Self::PymarkdownlntFix => (
                &pymarkdownlnt_fix::COMMANDS,
                pymarkdownlnt_fix::set_args,
                pymarkdownlnt_fix::IS_STDIN,
            ),
            Self::Pyment => (&pyment::COMMANDS, pyment::set_args, pyment::IS_STDIN),
            Self::Pyrefly => (&pyrefly::COMMANDS, pyrefly::set_args, pyrefly::IS_STDIN),
            Self::Pyupgrade => (
                &pyupgrade::COMMANDS,
                pyupgrade::set_args,
                pyupgrade::IS_STDIN,
            ),
            Self::Qmlfmt => (&qmlfmt::COMMANDS, qmlfmt::set_args, qmlfmt::IS_STDIN),
            Self::Qmlformat => (
                &qmlformat::COMMANDS,
                qmlformat::set_args,
                qmlformat::IS_STDIN,
            ),
            Self::Qmllint => (&qmllint::COMMANDS, qmllint::set_args, qmllint::IS_STDIN),
            Self::QuickLintJs => (
                &quick_lint_js::COMMANDS,
                quick_lint_js::set_args,
                quick_lint_js::IS_STDIN,
            ),
            Self::RacoFmt => (&raco_fmt::COMMANDS, raco_fmt::set_args, raco_fmt::IS_STDIN),
            Self::Reek => (&reek::COMMANDS, reek::set_args, reek::IS_STDIN),
            Self::Refmt => (&refmt::COMMANDS, refmt::set_args, refmt::IS_STDIN),
            Self::ReformatGherkin => (
                &reformat_gherkin::COMMANDS,
                reformat_gherkin::set_args,
                reformat_gherkin::IS_STDIN,
            ),
            Self::Refurb => (&refurb::COMMANDS, refurb::set_args, refurb::IS_STDIN),
            Self::RegalFix => (
                &regal_fix::COMMANDS,
                regal_fix::set_args,
                regal_fix::IS_STDIN,
            ),
            Self::RegalLint => (
                &regal_lint::COMMANDS,
                regal_lint::set_args,
                regal_lint::IS_STDIN,
            ),
            Self::ReorderPythonImports => (
                &reorder_python_imports::COMMANDS,
                reorder_python_imports::set_args,
                reorder_python_imports::IS_STDIN,
            ),
            Self::RescriptFormat => (
                &rescript_format::COMMANDS,
                rescript_format::set_args,
                rescript_format::IS_STDIN,
            ),
            Self::Revive => (&revive::COMMANDS, revive::set_args, revive::IS_STDIN),
            Self::RocFormat => (
                &roc_format::COMMANDS,
                roc_format::set_args,
                roc_format::IS_STDIN,
            ),
            Self::Rstfmt => (&rstfmt::COMMANDS, rstfmt::set_args, rstfmt::IS_STDIN),
            Self::Rubocop => (&rubocop::COMMANDS, rubocop::set_args, rubocop::IS_STDIN),
            Self::Rubyfmt => (&rubyfmt::COMMANDS, rubyfmt::set_args, rubyfmt::IS_STDIN),
            Self::RuffCheck => (
                &ruff_check::COMMANDS,
                ruff_check::set_args,
                ruff_check::IS_STDIN,
            ),
            Self::RuffFormat => (
                &ruff_format::COMMANDS,
                ruff_format::set_args,
                ruff_format::IS_STDIN,
            ),
            Self::Rufo => (&rufo::COMMANDS, rufo::set_args, rufo::IS_STDIN),
            Self::RumdlCheck => (
                &rumdl_check::COMMANDS,
                rumdl_check::set_args,
                rumdl_check::IS_STDIN,
            ),
            Self::RumdlCheckFix => (
                &rumdl_check_fix::COMMANDS,
                rumdl_check_fix::set_args,
                rumdl_check_fix::IS_STDIN,
            ),
            Self::RumdlFmt => (
                &rumdl_fmt::COMMANDS,
                rumdl_fmt::set_args,
                rumdl_fmt::IS_STDIN,
            ),
            Self::RuneFmt => (&rune_fmt::COMMANDS, rune_fmt::set_args, rune_fmt::IS_STDIN),
            Self::Runic => (&runic::COMMANDS, runic::set_args, runic::IS_STDIN),
            Self::Rustfmt => (&rustfmt::COMMANDS, rustfmt::set_args, rustfmt::IS_STDIN),
            Self::Rustfmt2015 => (
                &rustfmt_2015::COMMANDS,
                rustfmt_2015::set_args,
                rustfmt_2015::IS_STDIN,
            ),
            Self::Rustfmt2018 => (
                &rustfmt_2018::COMMANDS,
                rustfmt_2018::set_args,
                rustfmt_2018::IS_STDIN,
            ),
            Self::Rustfmt2021 => (
                &rustfmt_2021::COMMANDS,
                rustfmt_2021::set_args,
                rustfmt_2021::IS_STDIN,
            ),
            Self::Rustfmt2024 => (
                &rustfmt_2024::COMMANDS,
                rustfmt_2024::set_args,
                rustfmt_2024::IS_STDIN,
            ),
            Self::Rustywind => (
                &rustywind::COMMANDS,
                rustywind::set_args,
                rustywind::IS_STDIN,
            ),
            Self::SaltLint => (
                &salt_lint::COMMANDS,
                salt_lint::set_args,
                salt_lint::IS_STDIN,
            ),
            Self::Scala => (&scala::COMMANDS, scala::set_args, scala::IS_STDIN),
            Self::Scalafmt => (&scalafmt::COMMANDS, scalafmt::set_args, scalafmt::IS_STDIN),
            Self::Scalariform => (
                &scalariform::COMMANDS,
                scalariform::set_args,
                scalariform::IS_STDIN,
            ),
            Self::Selene => (&selene::COMMANDS, selene::set_args, selene::IS_STDIN),
            Self::Semistandard => (
                &semistandard::COMMANDS,
                semistandard::set_args,
                semistandard::IS_STDIN,
            ),
            Self::Shellcheck => (
                &shellcheck::COMMANDS,
                shellcheck::set_args,
                shellcheck::IS_STDIN,
            ),
            Self::Shellharden => (
                &shellharden::COMMANDS,
                shellharden::set_args,
                shellharden::IS_STDIN,
            ),
            Self::Shfmt => (&shfmt::COMMANDS, shfmt::set_args, shfmt::IS_STDIN),
            Self::Sleek => (&sleek::COMMANDS, sleek::set_args, sleek::IS_STDIN),
            Self::SlimLint => (
                &slim_lint::COMMANDS,
                slim_lint::set_args,
                slim_lint::IS_STDIN,
            ),
            Self::Smlfmt => (&smlfmt::COMMANDS, smlfmt::set_args, smlfmt::IS_STDIN),
            Self::Snakefmt => (&snakefmt::COMMANDS, snakefmt::set_args, snakefmt::IS_STDIN),
            Self::Solhint => (&solhint::COMMANDS, solhint::set_args, solhint::IS_STDIN),
            Self::SphinxLint => (
                &sphinx_lint::COMMANDS,
                sphinx_lint::set_args,
                sphinx_lint::IS_STDIN,
            ),
            Self::SqlFormatter => (
                &sql_formatter::COMMANDS,
                sql_formatter::set_args,
                sql_formatter::IS_STDIN,
            ),
            Self::SqlfluffFix => (
                &sqlfluff_fix::COMMANDS,
                sqlfluff_fix::set_args,
                sqlfluff_fix::IS_STDIN,
            ),
            Self::SqlfluffFormat => (
                &sqlfluff_format::COMMANDS,
                sqlfluff_format::set_args,
                sqlfluff_format::IS_STDIN,
            ),
            Self::SqlfluffLint => (
                &sqlfluff_lint::COMMANDS,
                sqlfluff_lint::set_args,
                sqlfluff_lint::IS_STDIN,
            ),
            Self::Sqlfmt => (&sqlfmt::COMMANDS, sqlfmt::set_args, sqlfmt::IS_STDIN),
            Self::Sqlint => (&sqlint::COMMANDS, sqlint::set_args, sqlint::IS_STDIN),
            Self::Sqruff => (&sqruff::COMMANDS, sqruff::set_args, sqruff::IS_STDIN),
            Self::Squawk => (&squawk::COMMANDS, squawk::set_args, squawk::IS_STDIN),
            Self::Standardjs => (
                &standardjs::COMMANDS,
                standardjs::set_args,
                standardjs::IS_STDIN,
            ),
            Self::Standardrb => (
                &standardrb::COMMANDS,
                standardrb::set_args,
                standardrb::IS_STDIN,
            ),
            Self::StatixCheck => (
                &statix_check::COMMANDS,
                statix_check::set_args,
                statix_check::IS_STDIN,
            ),
            Self::StatixFix => (
                &statix_fix::COMMANDS,
                statix_fix::set_args,
                statix_fix::IS_STDIN,
            ),
            Self::Stylefmt => (&stylefmt::COMMANDS, stylefmt::set_args, stylefmt::IS_STDIN),
            Self::Stylelint => (
                &stylelint::COMMANDS,
                stylelint::set_args,
                stylelint::IS_STDIN,
            ),
            Self::StylishHaskell => (
                &stylish_haskell::COMMANDS,
                stylish_haskell::set_args,
                stylish_haskell::IS_STDIN,
            ),
            Self::Stylua => (&stylua::COMMANDS, stylua::set_args, stylua::IS_STDIN),
            Self::SuperhtmlFmt => (
                &superhtml_fmt::COMMANDS,
                superhtml_fmt::set_args,
                superhtml_fmt::IS_STDIN,
            ),
            Self::Svlint => (&svlint::COMMANDS, svlint::set_args, svlint::IS_STDIN),
            Self::SwiftFormat => (
                &swift_format::COMMANDS,
                swift_format::set_args,
                swift_format::IS_STDIN,
            ),
            Self::Swiftformat => (
                &swiftformat::COMMANDS,
                swiftformat::set_args,
                swiftformat::IS_STDIN,
            ),
            Self::Swiftlint => (
                &swiftlint::COMMANDS,
                swiftlint::set_args,
                swiftlint::IS_STDIN,
            ),
            Self::Taplo => (&taplo::COMMANDS, taplo::set_args, taplo::IS_STDIN),
            Self::Tclfmt => (&tclfmt::COMMANDS, tclfmt::set_args, tclfmt::IS_STDIN),
            Self::Tclint => (&tclint::COMMANDS, tclint::set_args, tclint::IS_STDIN),
            Self::TemplFmt => (
                &templ_fmt::COMMANDS,
                templ_fmt::set_args,
                templ_fmt::IS_STDIN,
            ),
            Self::TerraformFmt => (
                &terraform_fmt::COMMANDS,
                terraform_fmt::set_args,
                terraform_fmt::IS_STDIN,
            ),
            Self::TerragruntHclfmt => (
                &terragrunt_hclfmt::COMMANDS,
                terragrunt_hclfmt::set_args,
                terragrunt_hclfmt::IS_STDIN,
            ),
            Self::TexFmt => (&tex_fmt::COMMANDS, tex_fmt::set_args, tex_fmt::IS_STDIN),
            Self::Textlint => (&textlint::COMMANDS, textlint::set_args, textlint::IS_STDIN),
            Self::TextlintFix => (
                &textlint_fix::COMMANDS,
                textlint_fix::set_args,
                textlint_fix::IS_STDIN,
            ),
            Self::TlintFormat => (
                &tlint_format::COMMANDS,
                tlint_format::set_args,
                tlint_format::IS_STDIN,
            ),
            Self::TofuFmt => (&tofu_fmt::COMMANDS, tofu_fmt::set_args, tofu_fmt::IS_STDIN),
            Self::TombiFormat => (
                &tombi_format::COMMANDS,
                tombi_format::set_args,
                tombi_format::IS_STDIN,
            ),
            Self::TombiLint => (
                &tombi_lint::COMMANDS,
                tombi_lint::set_args,
                tombi_lint::IS_STDIN,
            ),
            Self::TomlSort => (
                &toml_sort::COMMANDS,
                toml_sort::set_args,
                toml_sort::IS_STDIN,
            ),
            Self::Topiary => (&topiary::COMMANDS, topiary::set_args, topiary::IS_STDIN),
            Self::Tryceratops => (
                &tryceratops::COMMANDS,
                tryceratops::set_args,
                tryceratops::IS_STDIN,
            ),
            Self::TsStandard => (
                &ts_standard::COMMANDS,
                ts_standard::set_args,
                ts_standard::IS_STDIN,
            ),
            Self::TspFormat => (
                &tsp_format::COMMANDS,
                tsp_format::set_args,
                tsp_format::IS_STDIN,
            ),
            Self::Tsqllint => (&tsqllint::COMMANDS, tsqllint::set_args, tsqllint::IS_STDIN),
            Self::TwigCsFixerCheck => (
                &twig_cs_fixer_check::COMMANDS,
                twig_cs_fixer_check::set_args,
                twig_cs_fixer_check::IS_STDIN,
            ),
            Self::TwigCsFixerFix => (
                &twig_cs_fixer_fix::COMMANDS,
                twig_cs_fixer_fix::set_args,
                twig_cs_fixer_fix::IS_STDIN,
            ),
            Self::TwigCsFixerLint => (
                &twig_cs_fixer_lint::COMMANDS,
                twig_cs_fixer_lint::set_args,
                twig_cs_fixer_lint::IS_STDIN,
            ),
            Self::Twigcs => (&twigcs::COMMANDS, twigcs::set_args, twigcs::IS_STDIN),
            Self::Txtpbfmt => (&txtpbfmt::COMMANDS, txtpbfmt::set_args, txtpbfmt::IS_STDIN),
            Self::Ty => (&ty::COMMANDS, ty::set_args, ty::IS_STDIN),
            Self::Typos => (&typos::COMMANDS, typos::set_args, typos::IS_STDIN),
            Self::Typstfmt => (&typstfmt::COMMANDS, typstfmt::set_args, typstfmt::IS_STDIN),
            Self::Typstyle => (&typstyle::COMMANDS, typstyle::set_args, typstyle::IS_STDIN),
            Self::Ufmt => (&ufmt::COMMANDS, ufmt::set_args, ufmt::IS_STDIN),
            Self::UiuaFmt => (&uiua_fmt::COMMANDS, uiua_fmt::set_args, uiua_fmt::IS_STDIN),
            Self::Unimport => (&unimport::COMMANDS, unimport::set_args, unimport::IS_STDIN),
            Self::Usort => (&usort::COMMANDS, usort::set_args, usort::IS_STDIN),
            Self::VFmt => (&v_fmt::COMMANDS, v_fmt::set_args, v_fmt::IS_STDIN),
            Self::VacuumLint => (
                &vacuum_lint::COMMANDS,
                vacuum_lint::set_args,
                vacuum_lint::IS_STDIN,
            ),
            Self::Verusfmt => (&verusfmt::COMMANDS, verusfmt::set_args, verusfmt::IS_STDIN),
            Self::VerylFmt => (
                &veryl_fmt::COMMANDS,
                veryl_fmt::set_args,
                veryl_fmt::IS_STDIN,
            ),
            Self::VhdlStyleGuide => (
                &vhdl_style_guide::COMMANDS,
                vhdl_style_guide::set_args,
                vhdl_style_guide::IS_STDIN,
            ),
            Self::Vint => (&vint::COMMANDS, vint::set_args, vint::IS_STDIN),
            Self::VintNeovim => (
                &vint_neovim::COMMANDS,
                vint_neovim::set_args,
                vint_neovim::IS_STDIN,
            ),
            Self::WaFmt => (&wa_fmt::COMMANDS, wa_fmt::set_args, wa_fmt::IS_STDIN),
            Self::Wfindent => (&wfindent::COMMANDS, wfindent::set_args, wfindent::IS_STDIN),
            Self::WriteGood => (
                &write_good::COMMANDS,
                write_good::set_args,
                write_good::IS_STDIN,
            ),
            Self::Xmlformat => (
                &xmlformat::COMMANDS,
                xmlformat::set_args,
                xmlformat::IS_STDIN,
            ),
            Self::Xmllint => (&xmllint::COMMANDS, xmllint::set_args, xmllint::IS_STDIN),
            Self::Xo => (&xo::COMMANDS, xo::set_args, xo::IS_STDIN),
            Self::Xq => (&xq::COMMANDS, xq::set_args, xq::IS_STDIN),
            Self::XqHtml => (&xq_html::COMMANDS, xq_html::set_args, xq_html::IS_STDIN),
            Self::Yamlfix => (&yamlfix::COMMANDS, yamlfix::set_args, yamlfix::IS_STDIN),
            Self::Yamlfmt => (&yamlfmt::COMMANDS, yamlfmt::set_args, yamlfmt::IS_STDIN),
            Self::Yamllint => (&yamllint::COMMANDS, yamllint::set_args, yamllint::IS_STDIN),
            Self::Yapf => (&yapf::COMMANDS, yapf::set_args, yapf::IS_STDIN),
            Self::YardLint => (
                &yard_lint::COMMANDS,
                yard_lint::set_args,
                yard_lint::IS_STDIN,
            ),
            Self::YewFmt => (&yew_fmt::COMMANDS, yew_fmt::set_args, yew_fmt::IS_STDIN),
            Self::Yq => (&yq::COMMANDS, yq::set_args, yq::IS_STDIN),
            Self::ZigFmt => (&zig_fmt::COMMANDS, zig_fmt::set_args, zig_fmt::IS_STDIN),
            Self::ZiggyCheck => (
                &ziggy_check::COMMANDS,
                ziggy_check::set_args,
                ziggy_check::IS_STDIN,
            ),
            Self::ZiggyFmt => (
                &ziggy_fmt::COMMANDS,
                ziggy_fmt::set_args,
                ziggy_fmt::IS_STDIN,
            ),
            Self::Zprint => (&zprint::COMMANDS, zprint::set_args, zprint::IS_STDIN),
            Self::Zsweep => (&zsweep::COMMANDS, zsweep::set_args, zsweep::IS_STDIN),
            Self::Zuban => (&zuban::COMMANDS, zuban::set_args, zuban::IS_STDIN),
            Self::ZubanCheck => (
                &zuban_check::COMMANDS,
                zuban_check::set_args,
                zuban_check::IS_STDIN,
            ),
            Self::ZubanMypy => (
                &zuban_mypy::COMMANDS,
                zuban_mypy::set_args,
                zuban_mypy::IS_STDIN,
            ),
        };

        crate::execution::run_tools(
            commands,
            snippet_path,
            set_args_fn,
            timeout,
            is_stdin,
            debug_enabled,
            config_runners,
        )
    }
}

impl AsRef<str> for Tooling {
    #[allow(clippy::too_many_lines)]
    #[inline]
    fn as_ref(&self) -> &str {
        match self {
            Self::ActionValidator => "action-validator",
            Self::Actionlint => "actionlint",
            Self::AirFormat => "air:format",
            Self::Alejandra => "alejandra",
            Self::Alex => "alex",
            Self::Ameba => "ameba",
            Self::AnsibleLint => "ansible-lint",
            Self::ApiLinter => "api-linter",
            Self::Asmfmt => "asmfmt",
            Self::Astyle => "astyle",
            Self::AtlasFmt => "atlas:fmt",
            Self::AtlasLint => "atlas:lint",
            Self::AutoOptional => "auto-optional",
            Self::Autocorrect => "autocorrect",
            Self::Autoflake => "autoflake",
            Self::Autopep8 => "autopep8",
            Self::Bashate => "bashate",
            Self::BeancountBlack => "beancount-black",
            Self::Beautysh => "beautysh",
            Self::BibtexTidy => "bibtex-tidy",
            Self::BicepFormat => "bicep:format",
            Self::BiomeCheck => "biome:check",
            Self::BiomeCheckUnsafe => "biome:check:unsafe",
            Self::BiomeFormat => "biome:format",
            Self::BiomeLint => "biome:lint",
            Self::BiomeLintUnsafe => "biome:lint:unsafe",
            Self::Black => "black",
            Self::BladeFormatter => "blade-formatter",
            Self::Blue => "blue",
            Self::Bpfmt => "bpfmt",
            Self::Brittany => "brittany",
            Self::Brunette => "brunette",
            Self::Bsfmt => "bsfmt",
            Self::Bslint => "bslint",
            Self::BufFormat => "buf:format",
            Self::BufLint => "buf:lint",
            Self::Buildifier => "buildifier",
            Self::CabalFmt => "cabal-fmt",
            Self::CabalFormat => "cabal:format",
            Self::CabalGild => "cabal-gild",
            Self::CabalPrettify => "cabal-prettify",
            Self::CaddyFmt => "caddy:fmt",
            Self::CaramelFmt => "caramel:fmt",
            Self::CedarFormat => "cedar:format",
            Self::CfnLint => "cfn-lint",
            Self::Checkmake => "checkmake",
            Self::ClangFormat => "clang-format",
            Self::ClangTidy => "clang-tidy",
            Self::CljKondo => "clj-kondo",
            Self::CljfmtFix => "cljfmt:fix",
            Self::Cljstyle => "cljstyle",
            Self::CmakeFormat => "cmake-format",
            Self::CmakeLint => "cmake-lint",
            Self::CodeqlQueryFormat => "codeql:query:format",
            Self::Codespell => "codespell",
            Self::Coffeelint => "coffeelint",
            Self::Cppcheck => "cppcheck",
            Self::Cpplint => "cpplint",
            Self::Crlfmt => "crlfmt",
            Self::CrystalFormat => "crystal:format",
            Self::Csharpier => "csharpier",
            Self::CssBeautify => "css-beautify",
            Self::Csscomb => "csscomb",
            Self::Csslint => "csslint",
            Self::CueFmt => "cue:fmt",
            Self::Cueimports => "cueimports",
            Self::Curlylint => "curlylint",
            Self::D2Fmt => "d2:fmt",
            Self::DartFix => "dart:fix",
            Self::DartFormat => "dart:format",
            Self::DcmFix => "dcm:fix",
            Self::DcmFormat => "dcm:format",
            Self::Deadnix => "deadnix",
            Self::DenoFmt => "deno:fmt",
            Self::DenoLint => "deno:lint",
            Self::Dfmt => "dfmt",
            Self::DhallFormat => "dhall:format",
            Self::DhallLint => "dhall:lint",
            Self::Djade => "djade",
            Self::Djlint => "djlint",
            Self::Docformatter => "docformatter",
            Self::Dockerfmt => "dockerfmt",
            Self::Dockfmt => "dockfmt",
            Self::Docstrfmt => "docstrfmt",
            Self::Doctoc => "doctoc",
            Self::DotenvLinterFix => "dotenv-linter:fix",
            Self::DprintFmt => "dprint:fmt",
            Self::DscannerFix => "dscanner:fix",
            Self::DscannerLint => "dscanner:lint",
            Self::DuneFormatDuneFile => "dune:format-dune-file",
            Self::DusterFix => "duster:fix",
            Self::DusterLint => "duster:lint",
            Self::DxFmt => "dx:fmt",
            Self::EasyCodingStandard => "easy-coding-standard",
            Self::Efmt => "efmt",
            Self::ElmFormat => "elm-format",
            Self::Eradicate => "eradicate",
            Self::ErbFormatter => "erb-formatter",
            Self::ErgLint => "erg:lint",
            Self::Erlfmt => "erlfmt",
            Self::Eslint => "eslint",
            Self::Fantomas => "fantomas",
            Self::FishIndent => "fish_indent",
            Self::Fixjson => "fixjson",
            Self::Floskell => "floskell",
            Self::Flynt => "flynt",
            Self::Fnlfmt => "fnlfmt",
            Self::ForgeFmt => "forge:fmt",
            Self::FortitudeCheck => "fortitude:check",
            Self::FortitudeCheckFix => "fortitude:check:fix",
            Self::FortitudeCheckFixUnsafe => "fortitude:check:fix:unsafe",
            Self::FortranLinter => "fortran-linter",
            Self::Fourmolu => "fourmolu",
            Self::Fprettify => "fprettify",
            Self::FutharkFmt => "futhark:fmt",
            Self::FvmDartFix => "fvm:dart:fix",
            Self::FvmDartFormat => "fvm:dart:format",
            Self::Gci => "gci",
            Self::Gdformat => "gdformat",
            Self::Gdlint => "gdlint",
            Self::Gersemi => "gersemi",
            Self::GhokinCheck => "ghokin:check",
            Self::GhokinFmt => "ghokin:fmt",
            Self::GleamFormat => "gleam:format",
            Self::GluonFmt => "gluon:fmt",
            Self::Gofmt => "gofmt",
            Self::Gofumpt => "gofumpt",
            Self::Goimports => "goimports",
            Self::GoimportsReviser => "goimports-reviser",
            Self::GolangciLintFmt => "golangci-lint:fmt",
            Self::GolangciLintRun => "golangci-lint:run",
            Self::GolangciLintRunFix => "golangci-lint:run:fix",
            Self::Golines => "golines",
            Self::GoogleJavaFormat => "google-java-format",
            Self::Gospel => "gospel",
            Self::GrafbaseLint => "grafbase:lint",
            Self::GrainFormat => "grain:format",
            Self::Hadolint => "hadolint",
            Self::HamlLint => "haml-lint",
            Self::Hclfmt => "hclfmt",
            Self::Hfmt => "hfmt",
            Self::Hindent => "hindent",
            Self::Hlint => "hlint",
            Self::HtmlBeautify => "html-beautify",
            Self::Htmlbeautifier => "htmlbeautifier",
            Self::Htmlhint => "htmlhint",
            Self::Hurlfmt => "hurlfmt",
            Self::ImbaFmt => "imba:fmt",
            Self::InkoFmt => "inko:fmt",
            Self::Isort => "isort",
            Self::JanetFormat => "janet-format",
            Self::Joker => "joker",
            Self::Jq => "jq",
            Self::Jqfmt => "jqfmt",
            Self::JsBeautify => "js-beautify",
            Self::Json5Format => "json5format",
            Self::JsonRepair => "json_repair",
            Self::JsonaFormat => "jsona:format",
            Self::JsonaLint => "jsona:lint",
            Self::Jsonlint => "jsonlint",
            Self::JsonlintSort => "jsonlint:sort",
            Self::JsonnetLint => "jsonnet-lint",
            Self::Jsonnetfmt => "jsonnetfmt",
            Self::Jsonpp => "jsonpp",
            Self::JuliaformatterJl => "juliaformatter.jl",
            Self::Just => "just",
            Self::KclFmt => "kcl:fmt",
            Self::KclLint => "kcl:lint",
            Self::Kdlfmt => "kdlfmt",
            Self::KdlfmtV1 => "kdlfmt:v1",
            Self::KdlfmtV2 => "kdlfmt:v2",
            Self::KdocFormatter => "kdoc-formatter",
            Self::KeepSorted => "keep-sorted",
            Self::Ktfmt => "ktfmt",
            Self::Ktlint => "ktlint",
            Self::KubeLinterLint => "kube-linter:lint",
            Self::KulalaFmtCheck => "kulala-fmt:check",
            Self::KulalaFmtFormat => "kulala-fmt:format",
            Self::Leptosfmt => "leptosfmt",
            Self::LiquidsoapPrettier => "liquidsoap-prettier",
            Self::Luacheck => "luacheck",
            Self::Luaformatter => "luaformatter",
            Self::LuauAnalyze => "luau-analyze",
            Self::MadoCheck => "mado:check",
            Self::MagoAnalyze => "mago:analyze",
            Self::MagoAnalyzeFix => "mago:analyze:fix",
            Self::MagoAnalyzeFixUnsafe => "mago:analyze:fix:unsafe",
            Self::MagoFormat => "mago:format",
            Self::MagoLint => "mago:lint",
            Self::MagoLintFix => "mago:lint:fix",
            Self::MagoLintFixUnsafe => "mago:lint:fix:unsafe",
            Self::Markdownfmt => "markdownfmt",
            Self::Markdownlint => "markdownlint",
            Self::MarkdownlintCli2 => "markdownlint-cli2",
            Self::Markuplint => "markuplint",
            Self::MbakeFormat => "mbake:format",
            Self::MbakeValidate => "mbake:validate",
            Self::MdPadding => "md-padding",
            Self::Mdformat => "mdformat",
            Self::MdsfFormat => "mdsf:format",
            Self::MdsfVerify => "mdsf:verify",
            Self::Mdslw => "mdslw",
            Self::MesonFmt => "meson:fmt",
            Self::MhLint => "mh_lint",
            Self::MhStyle => "mh_style",
            Self::MiseFmt => "mise:fmt",
            Self::Misspell => "misspell",
            Self::MixFormat => "mix:format",
            Self::MojoFormat => "mojo:format",
            Self::MuonFmt => "muon:fmt",
            Self::MuonLint => "muon:lint",
            Self::Mypy => "mypy",
            Self::Nasmfmt => "nasmfmt",
            Self::Nginxbeautifier => "nginxbeautifier",
            Self::Nginxfmt => "nginxfmt",
            Self::NickelFormat => "nickel:format",
            Self::Nimpretty => "nimpretty",
            Self::Nixfmt => "nixfmt",
            Self::NixpkgsFmt => "nixpkgs-fmt",
            Self::NomadFmt => "nomad:fmt",
            Self::Nph => "nph",
            Self::NpmGroovyLint => "npm-groovy-lint",
            Self::Nufmt => "nufmt",
            Self::Ocamlformat => "ocamlformat",
            Self::OcpIndent => "ocp-indent",
            Self::Odinfmt => "odinfmt",
            Self::OelintAdv => "oelint-adv",
            Self::OpaFmt => "opa:fmt",
            Self::Ormolu => "ormolu",
            Self::Oxfmt => "oxfmt",
            Self::Oxlint => "oxlint",
            Self::PackerFix => "packer:fix",
            Self::PackerFmt => "packer:fmt",
            Self::PackerValidate => "packer:validate",
            Self::Pasfmt => "pasfmt",
            Self::Perflint => "perflint",
            Self::Perltidy => "perltidy",
            Self::PgFormat => "pg_format",
            Self::PhpCsFixerFix => "php-cs-fixer:fix",
            Self::Phpcbf => "phpcbf",
            Self::PhpinsightsFix => "phpinsights:fix",
            Self::Pint => "pint",
            Self::PklFormat => "pkl:format",
            Self::Prettier => "prettier",
            Self::Prettierd => "prettierd",
            Self::PrettyPhp => "pretty-php",
            Self::Prettypst => "prettypst",
            Self::PrismaFormat => "prisma:format",
            Self::Proselint => "proselint",
            Self::Protolint => "protolint",
            Self::Ptop => "ptop",
            Self::PugLint => "pug-lint",
            Self::PuppetLint => "puppet-lint",
            Self::PursTidy => "purs-tidy",
            Self::Purty => "purty",
            Self::Pycln => "pycln",
            Self::Pycodestyle => "pycodestyle",
            Self::Pydoclint => "pydoclint",
            Self::Pydocstringformatter => "pydocstringformatter",
            Self::Pydocstyle => "pydocstyle",
            Self::Pyflakes => "pyflakes",
            Self::Pyink => "pyink",
            Self::Pylint => "pylint",
            Self::PymarkdownlntFix => "pymarkdownlnt:fix",
            Self::Pyment => "pyment",
            Self::Pyrefly => "pyrefly",
            Self::Pyupgrade => "pyupgrade",
            Self::Qmlfmt => "qmlfmt",
            Self::Qmlformat => "qmlformat",
            Self::Qmllint => "qmllint",
            Self::QuickLintJs => "quick-lint-js",
            Self::RacoFmt => "raco:fmt",
            Self::Reek => "reek",
            Self::Refmt => "refmt",
            Self::ReformatGherkin => "reformat-gherkin",
            Self::Refurb => "refurb",
            Self::RegalFix => "regal:fix",
            Self::RegalLint => "regal:lint",
            Self::ReorderPythonImports => "reorder-python-imports",
            Self::RescriptFormat => "rescript:format",
            Self::Revive => "revive",
            Self::RocFormat => "roc:format",
            Self::Rstfmt => "rstfmt",
            Self::Rubocop => "rubocop",
            Self::Rubyfmt => "rubyfmt",
            Self::RuffCheck => "ruff:check",
            Self::RuffFormat => "ruff:format",
            Self::Rufo => "rufo",
            Self::RumdlCheck => "rumdl:check",
            Self::RumdlCheckFix => "rumdl:check:fix",
            Self::RumdlFmt => "rumdl:fmt",
            Self::RuneFmt => "rune:fmt",
            Self::Runic => "runic",
            Self::Rustfmt => "rustfmt",
            Self::Rustfmt2015 => "rustfmt:2015",
            Self::Rustfmt2018 => "rustfmt:2018",
            Self::Rustfmt2021 => "rustfmt:2021",
            Self::Rustfmt2024 => "rustfmt:2024",
            Self::Rustywind => "rustywind",
            Self::SaltLint => "salt-lint",
            Self::Scala => "scala",
            Self::Scalafmt => "scalafmt",
            Self::Scalariform => "scalariform",
            Self::Selene => "selene",
            Self::Semistandard => "semistandard",
            Self::Shellcheck => "shellcheck",
            Self::Shellharden => "shellharden",
            Self::Shfmt => "shfmt",
            Self::Sleek => "sleek",
            Self::SlimLint => "slim-lint",
            Self::Smlfmt => "smlfmt",
            Self::Snakefmt => "snakefmt",
            Self::Solhint => "solhint",
            Self::SphinxLint => "sphinx-lint",
            Self::SqlFormatter => "sql-formatter",
            Self::SqlfluffFix => "sqlfluff:fix",
            Self::SqlfluffFormat => "sqlfluff:format",
            Self::SqlfluffLint => "sqlfluff:lint",
            Self::Sqlfmt => "sqlfmt",
            Self::Sqlint => "sqlint",
            Self::Sqruff => "sqruff",
            Self::Squawk => "squawk",
            Self::Standardjs => "standardjs",
            Self::Standardrb => "standardrb",
            Self::StatixCheck => "statix:check",
            Self::StatixFix => "statix:fix",
            Self::Stylefmt => "stylefmt",
            Self::Stylelint => "stylelint",
            Self::StylishHaskell => "stylish-haskell",
            Self::Stylua => "stylua",
            Self::SuperhtmlFmt => "superhtml:fmt",
            Self::Svlint => "svlint",
            Self::SwiftFormat => "swift-format",
            Self::Swiftformat => "swiftformat",
            Self::Swiftlint => "swiftlint",
            Self::Taplo => "taplo",
            Self::Tclfmt => "tclfmt",
            Self::Tclint => "tclint",
            Self::TemplFmt => "templ:fmt",
            Self::TerraformFmt => "terraform:fmt",
            Self::TerragruntHclfmt => "terragrunt:hclfmt",
            Self::TexFmt => "tex-fmt",
            Self::Textlint => "textlint",
            Self::TextlintFix => "textlint:fix",
            Self::TlintFormat => "tlint:format",
            Self::TofuFmt => "tofu:fmt",
            Self::TombiFormat => "tombi:format",
            Self::TombiLint => "tombi:lint",
            Self::TomlSort => "toml-sort",
            Self::Topiary => "topiary",
            Self::Tryceratops => "tryceratops",
            Self::TsStandard => "ts-standard",
            Self::TspFormat => "tsp:format",
            Self::Tsqllint => "tsqllint",
            Self::TwigCsFixerCheck => "twig-cs-fixer:check",
            Self::TwigCsFixerFix => "twig-cs-fixer:fix",
            Self::TwigCsFixerLint => "twig-cs-fixer:lint",
            Self::Twigcs => "twigcs",
            Self::Txtpbfmt => "txtpbfmt",
            Self::Ty => "ty",
            Self::Typos => "typos",
            Self::Typstfmt => "typstfmt",
            Self::Typstyle => "typstyle",
            Self::Ufmt => "ufmt",
            Self::UiuaFmt => "uiua:fmt",
            Self::Unimport => "unimport",
            Self::Usort => "usort",
            Self::VFmt => "v:fmt",
            Self::VacuumLint => "vacuum:lint",
            Self::Verusfmt => "verusfmt",
            Self::VerylFmt => "veryl:fmt",
            Self::VhdlStyleGuide => "vhdl-style-guide",
            Self::Vint => "vint",
            Self::VintNeovim => "vint:neovim",
            Self::WaFmt => "wa:fmt",
            Self::Wfindent => "wfindent",
            Self::WriteGood => "write-good",
            Self::Xmlformat => "xmlformat",
            Self::Xmllint => "xmllint",
            Self::Xo => "xo",
            Self::Xq => "xq",
            Self::XqHtml => "xq:html",
            Self::Yamlfix => "yamlfix",
            Self::Yamlfmt => "yamlfmt",
            Self::Yamllint => "yamllint",
            Self::Yapf => "yapf",
            Self::YardLint => "yard-lint",
            Self::YewFmt => "yew-fmt",
            Self::Yq => "yq",
            Self::ZigFmt => "zig:fmt",
            Self::ZiggyCheck => "ziggy:check",
            Self::ZiggyFmt => "ziggy:fmt",
            Self::Zprint => "zprint",
            Self::Zsweep => "zsweep",
            Self::Zuban => "zuban",
            Self::ZubanCheck => "zuban:check",
            Self::ZubanMypy => "zuban:mypy",
        }
    }
}

#[cfg(test)]
mod test_tooling {
    use super::Tooling;

    fn reverse(tooling: Tooling) -> Result<Tooling, serde_json::Error> {
        serde_json::from_str::<Tooling>(&format!("\"{}\"", tooling.as_ref()))
    }

    #[allow(clippy::cognitive_complexity)]
    #[allow(clippy::too_many_lines)]
    #[test]
    fn value_is_reversible() -> Result<(), serde_json::Error> {
        assert_eq!(Tooling::ActionValidator, reverse(Tooling::ActionValidator)?);
        assert_eq!(Tooling::Actionlint, reverse(Tooling::Actionlint)?);
        assert_eq!(Tooling::AirFormat, reverse(Tooling::AirFormat)?);
        assert_eq!(Tooling::Alejandra, reverse(Tooling::Alejandra)?);
        assert_eq!(Tooling::Alex, reverse(Tooling::Alex)?);
        assert_eq!(Tooling::Ameba, reverse(Tooling::Ameba)?);
        assert_eq!(Tooling::AnsibleLint, reverse(Tooling::AnsibleLint)?);
        assert_eq!(Tooling::ApiLinter, reverse(Tooling::ApiLinter)?);
        assert_eq!(Tooling::Asmfmt, reverse(Tooling::Asmfmt)?);
        assert_eq!(Tooling::Astyle, reverse(Tooling::Astyle)?);
        assert_eq!(Tooling::AtlasFmt, reverse(Tooling::AtlasFmt)?);
        assert_eq!(Tooling::AtlasLint, reverse(Tooling::AtlasLint)?);
        assert_eq!(Tooling::AutoOptional, reverse(Tooling::AutoOptional)?);
        assert_eq!(Tooling::Autocorrect, reverse(Tooling::Autocorrect)?);
        assert_eq!(Tooling::Autoflake, reverse(Tooling::Autoflake)?);
        assert_eq!(Tooling::Autopep8, reverse(Tooling::Autopep8)?);
        assert_eq!(Tooling::Bashate, reverse(Tooling::Bashate)?);
        assert_eq!(Tooling::BeancountBlack, reverse(Tooling::BeancountBlack)?);
        assert_eq!(Tooling::Beautysh, reverse(Tooling::Beautysh)?);
        assert_eq!(Tooling::BibtexTidy, reverse(Tooling::BibtexTidy)?);
        assert_eq!(Tooling::BicepFormat, reverse(Tooling::BicepFormat)?);
        assert_eq!(Tooling::BiomeCheck, reverse(Tooling::BiomeCheck)?);
        assert_eq!(
            Tooling::BiomeCheckUnsafe,
            reverse(Tooling::BiomeCheckUnsafe)?
        );
        assert_eq!(Tooling::BiomeFormat, reverse(Tooling::BiomeFormat)?);
        assert_eq!(Tooling::BiomeLint, reverse(Tooling::BiomeLint)?);
        assert_eq!(Tooling::BiomeLintUnsafe, reverse(Tooling::BiomeLintUnsafe)?);
        assert_eq!(Tooling::Black, reverse(Tooling::Black)?);
        assert_eq!(Tooling::BladeFormatter, reverse(Tooling::BladeFormatter)?);
        assert_eq!(Tooling::Blue, reverse(Tooling::Blue)?);
        assert_eq!(Tooling::Bpfmt, reverse(Tooling::Bpfmt)?);
        assert_eq!(Tooling::Brittany, reverse(Tooling::Brittany)?);
        assert_eq!(Tooling::Brunette, reverse(Tooling::Brunette)?);
        assert_eq!(Tooling::Bsfmt, reverse(Tooling::Bsfmt)?);
        assert_eq!(Tooling::Bslint, reverse(Tooling::Bslint)?);
        assert_eq!(Tooling::BufFormat, reverse(Tooling::BufFormat)?);
        assert_eq!(Tooling::BufLint, reverse(Tooling::BufLint)?);
        assert_eq!(Tooling::Buildifier, reverse(Tooling::Buildifier)?);
        assert_eq!(Tooling::CabalFmt, reverse(Tooling::CabalFmt)?);
        assert_eq!(Tooling::CabalFormat, reverse(Tooling::CabalFormat)?);
        assert_eq!(Tooling::CabalGild, reverse(Tooling::CabalGild)?);
        assert_eq!(Tooling::CabalPrettify, reverse(Tooling::CabalPrettify)?);
        assert_eq!(Tooling::CaddyFmt, reverse(Tooling::CaddyFmt)?);
        assert_eq!(Tooling::CaramelFmt, reverse(Tooling::CaramelFmt)?);
        assert_eq!(Tooling::CedarFormat, reverse(Tooling::CedarFormat)?);
        assert_eq!(Tooling::CfnLint, reverse(Tooling::CfnLint)?);
        assert_eq!(Tooling::Checkmake, reverse(Tooling::Checkmake)?);
        assert_eq!(Tooling::ClangFormat, reverse(Tooling::ClangFormat)?);
        assert_eq!(Tooling::ClangTidy, reverse(Tooling::ClangTidy)?);
        assert_eq!(Tooling::CljKondo, reverse(Tooling::CljKondo)?);
        assert_eq!(Tooling::CljfmtFix, reverse(Tooling::CljfmtFix)?);
        assert_eq!(Tooling::Cljstyle, reverse(Tooling::Cljstyle)?);
        assert_eq!(Tooling::CmakeFormat, reverse(Tooling::CmakeFormat)?);
        assert_eq!(Tooling::CmakeLint, reverse(Tooling::CmakeLint)?);
        assert_eq!(
            Tooling::CodeqlQueryFormat,
            reverse(Tooling::CodeqlQueryFormat)?
        );
        assert_eq!(Tooling::Codespell, reverse(Tooling::Codespell)?);
        assert_eq!(Tooling::Coffeelint, reverse(Tooling::Coffeelint)?);
        assert_eq!(Tooling::Cppcheck, reverse(Tooling::Cppcheck)?);
        assert_eq!(Tooling::Cpplint, reverse(Tooling::Cpplint)?);
        assert_eq!(Tooling::Crlfmt, reverse(Tooling::Crlfmt)?);
        assert_eq!(Tooling::CrystalFormat, reverse(Tooling::CrystalFormat)?);
        assert_eq!(Tooling::Csharpier, reverse(Tooling::Csharpier)?);
        assert_eq!(Tooling::CssBeautify, reverse(Tooling::CssBeautify)?);
        assert_eq!(Tooling::Csscomb, reverse(Tooling::Csscomb)?);
        assert_eq!(Tooling::Csslint, reverse(Tooling::Csslint)?);
        assert_eq!(Tooling::CueFmt, reverse(Tooling::CueFmt)?);
        assert_eq!(Tooling::Cueimports, reverse(Tooling::Cueimports)?);
        assert_eq!(Tooling::Curlylint, reverse(Tooling::Curlylint)?);
        assert_eq!(Tooling::D2Fmt, reverse(Tooling::D2Fmt)?);
        assert_eq!(Tooling::DartFix, reverse(Tooling::DartFix)?);
        assert_eq!(Tooling::DartFormat, reverse(Tooling::DartFormat)?);
        assert_eq!(Tooling::DcmFix, reverse(Tooling::DcmFix)?);
        assert_eq!(Tooling::DcmFormat, reverse(Tooling::DcmFormat)?);
        assert_eq!(Tooling::Deadnix, reverse(Tooling::Deadnix)?);
        assert_eq!(Tooling::DenoFmt, reverse(Tooling::DenoFmt)?);
        assert_eq!(Tooling::DenoLint, reverse(Tooling::DenoLint)?);
        assert_eq!(Tooling::Dfmt, reverse(Tooling::Dfmt)?);
        assert_eq!(Tooling::DhallFormat, reverse(Tooling::DhallFormat)?);
        assert_eq!(Tooling::DhallLint, reverse(Tooling::DhallLint)?);
        assert_eq!(Tooling::Djade, reverse(Tooling::Djade)?);
        assert_eq!(Tooling::Djlint, reverse(Tooling::Djlint)?);
        assert_eq!(Tooling::Docformatter, reverse(Tooling::Docformatter)?);
        assert_eq!(Tooling::Dockerfmt, reverse(Tooling::Dockerfmt)?);
        assert_eq!(Tooling::Dockfmt, reverse(Tooling::Dockfmt)?);
        assert_eq!(Tooling::Docstrfmt, reverse(Tooling::Docstrfmt)?);
        assert_eq!(Tooling::Doctoc, reverse(Tooling::Doctoc)?);
        assert_eq!(Tooling::DotenvLinterFix, reverse(Tooling::DotenvLinterFix)?);
        assert_eq!(Tooling::DprintFmt, reverse(Tooling::DprintFmt)?);
        assert_eq!(Tooling::DscannerFix, reverse(Tooling::DscannerFix)?);
        assert_eq!(Tooling::DscannerLint, reverse(Tooling::DscannerLint)?);
        assert_eq!(
            Tooling::DuneFormatDuneFile,
            reverse(Tooling::DuneFormatDuneFile)?
        );
        assert_eq!(Tooling::DusterFix, reverse(Tooling::DusterFix)?);
        assert_eq!(Tooling::DusterLint, reverse(Tooling::DusterLint)?);
        assert_eq!(Tooling::DxFmt, reverse(Tooling::DxFmt)?);
        assert_eq!(
            Tooling::EasyCodingStandard,
            reverse(Tooling::EasyCodingStandard)?
        );
        assert_eq!(Tooling::Efmt, reverse(Tooling::Efmt)?);
        assert_eq!(Tooling::ElmFormat, reverse(Tooling::ElmFormat)?);
        assert_eq!(Tooling::Eradicate, reverse(Tooling::Eradicate)?);
        assert_eq!(Tooling::ErbFormatter, reverse(Tooling::ErbFormatter)?);
        assert_eq!(Tooling::ErgLint, reverse(Tooling::ErgLint)?);
        assert_eq!(Tooling::Erlfmt, reverse(Tooling::Erlfmt)?);
        assert_eq!(Tooling::Eslint, reverse(Tooling::Eslint)?);
        assert_eq!(Tooling::Fantomas, reverse(Tooling::Fantomas)?);
        assert_eq!(Tooling::FishIndent, reverse(Tooling::FishIndent)?);
        assert_eq!(Tooling::Fixjson, reverse(Tooling::Fixjson)?);
        assert_eq!(Tooling::Floskell, reverse(Tooling::Floskell)?);
        assert_eq!(Tooling::Flynt, reverse(Tooling::Flynt)?);
        assert_eq!(Tooling::Fnlfmt, reverse(Tooling::Fnlfmt)?);
        assert_eq!(Tooling::ForgeFmt, reverse(Tooling::ForgeFmt)?);
        assert_eq!(Tooling::FortitudeCheck, reverse(Tooling::FortitudeCheck)?);
        assert_eq!(
            Tooling::FortitudeCheckFix,
            reverse(Tooling::FortitudeCheckFix)?
        );
        assert_eq!(
            Tooling::FortitudeCheckFixUnsafe,
            reverse(Tooling::FortitudeCheckFixUnsafe)?
        );
        assert_eq!(Tooling::FortranLinter, reverse(Tooling::FortranLinter)?);
        assert_eq!(Tooling::Fourmolu, reverse(Tooling::Fourmolu)?);
        assert_eq!(Tooling::Fprettify, reverse(Tooling::Fprettify)?);
        assert_eq!(Tooling::FutharkFmt, reverse(Tooling::FutharkFmt)?);
        assert_eq!(Tooling::FvmDartFix, reverse(Tooling::FvmDartFix)?);
        assert_eq!(Tooling::FvmDartFormat, reverse(Tooling::FvmDartFormat)?);
        assert_eq!(Tooling::Gci, reverse(Tooling::Gci)?);
        assert_eq!(Tooling::Gdformat, reverse(Tooling::Gdformat)?);
        assert_eq!(Tooling::Gdlint, reverse(Tooling::Gdlint)?);
        assert_eq!(Tooling::Gersemi, reverse(Tooling::Gersemi)?);
        assert_eq!(Tooling::GhokinCheck, reverse(Tooling::GhokinCheck)?);
        assert_eq!(Tooling::GhokinFmt, reverse(Tooling::GhokinFmt)?);
        assert_eq!(Tooling::GleamFormat, reverse(Tooling::GleamFormat)?);
        assert_eq!(Tooling::GluonFmt, reverse(Tooling::GluonFmt)?);
        assert_eq!(Tooling::Gofmt, reverse(Tooling::Gofmt)?);
        assert_eq!(Tooling::Gofumpt, reverse(Tooling::Gofumpt)?);
        assert_eq!(Tooling::Goimports, reverse(Tooling::Goimports)?);
        assert_eq!(
            Tooling::GoimportsReviser,
            reverse(Tooling::GoimportsReviser)?
        );
        assert_eq!(Tooling::GolangciLintFmt, reverse(Tooling::GolangciLintFmt)?);
        assert_eq!(Tooling::GolangciLintRun, reverse(Tooling::GolangciLintRun)?);
        assert_eq!(
            Tooling::GolangciLintRunFix,
            reverse(Tooling::GolangciLintRunFix)?
        );
        assert_eq!(Tooling::Golines, reverse(Tooling::Golines)?);
        assert_eq!(
            Tooling::GoogleJavaFormat,
            reverse(Tooling::GoogleJavaFormat)?
        );
        assert_eq!(Tooling::Gospel, reverse(Tooling::Gospel)?);
        assert_eq!(Tooling::GrafbaseLint, reverse(Tooling::GrafbaseLint)?);
        assert_eq!(Tooling::GrainFormat, reverse(Tooling::GrainFormat)?);
        assert_eq!(Tooling::Hadolint, reverse(Tooling::Hadolint)?);
        assert_eq!(Tooling::HamlLint, reverse(Tooling::HamlLint)?);
        assert_eq!(Tooling::Hclfmt, reverse(Tooling::Hclfmt)?);
        assert_eq!(Tooling::Hfmt, reverse(Tooling::Hfmt)?);
        assert_eq!(Tooling::Hindent, reverse(Tooling::Hindent)?);
        assert_eq!(Tooling::Hlint, reverse(Tooling::Hlint)?);
        assert_eq!(Tooling::HtmlBeautify, reverse(Tooling::HtmlBeautify)?);
        assert_eq!(Tooling::Htmlbeautifier, reverse(Tooling::Htmlbeautifier)?);
        assert_eq!(Tooling::Htmlhint, reverse(Tooling::Htmlhint)?);
        assert_eq!(Tooling::Hurlfmt, reverse(Tooling::Hurlfmt)?);
        assert_eq!(Tooling::ImbaFmt, reverse(Tooling::ImbaFmt)?);
        assert_eq!(Tooling::InkoFmt, reverse(Tooling::InkoFmt)?);
        assert_eq!(Tooling::Isort, reverse(Tooling::Isort)?);
        assert_eq!(Tooling::JanetFormat, reverse(Tooling::JanetFormat)?);
        assert_eq!(Tooling::Joker, reverse(Tooling::Joker)?);
        assert_eq!(Tooling::Jq, reverse(Tooling::Jq)?);
        assert_eq!(Tooling::Jqfmt, reverse(Tooling::Jqfmt)?);
        assert_eq!(Tooling::JsBeautify, reverse(Tooling::JsBeautify)?);
        assert_eq!(Tooling::Json5Format, reverse(Tooling::Json5Format)?);
        assert_eq!(Tooling::JsonRepair, reverse(Tooling::JsonRepair)?);
        assert_eq!(Tooling::JsonaFormat, reverse(Tooling::JsonaFormat)?);
        assert_eq!(Tooling::JsonaLint, reverse(Tooling::JsonaLint)?);
        assert_eq!(Tooling::Jsonlint, reverse(Tooling::Jsonlint)?);
        assert_eq!(Tooling::JsonlintSort, reverse(Tooling::JsonlintSort)?);
        assert_eq!(Tooling::JsonnetLint, reverse(Tooling::JsonnetLint)?);
        assert_eq!(Tooling::Jsonnetfmt, reverse(Tooling::Jsonnetfmt)?);
        assert_eq!(Tooling::Jsonpp, reverse(Tooling::Jsonpp)?);
        assert_eq!(
            Tooling::JuliaformatterJl,
            reverse(Tooling::JuliaformatterJl)?
        );
        assert_eq!(Tooling::Just, reverse(Tooling::Just)?);
        assert_eq!(Tooling::KclFmt, reverse(Tooling::KclFmt)?);
        assert_eq!(Tooling::KclLint, reverse(Tooling::KclLint)?);
        assert_eq!(Tooling::Kdlfmt, reverse(Tooling::Kdlfmt)?);
        assert_eq!(Tooling::KdlfmtV1, reverse(Tooling::KdlfmtV1)?);
        assert_eq!(Tooling::KdlfmtV2, reverse(Tooling::KdlfmtV2)?);
        assert_eq!(Tooling::KdocFormatter, reverse(Tooling::KdocFormatter)?);
        assert_eq!(Tooling::KeepSorted, reverse(Tooling::KeepSorted)?);
        assert_eq!(Tooling::Ktfmt, reverse(Tooling::Ktfmt)?);
        assert_eq!(Tooling::Ktlint, reverse(Tooling::Ktlint)?);
        assert_eq!(Tooling::KubeLinterLint, reverse(Tooling::KubeLinterLint)?);
        assert_eq!(Tooling::KulalaFmtCheck, reverse(Tooling::KulalaFmtCheck)?);
        assert_eq!(Tooling::KulalaFmtFormat, reverse(Tooling::KulalaFmtFormat)?);
        assert_eq!(Tooling::Leptosfmt, reverse(Tooling::Leptosfmt)?);
        assert_eq!(
            Tooling::LiquidsoapPrettier,
            reverse(Tooling::LiquidsoapPrettier)?
        );
        assert_eq!(Tooling::Luacheck, reverse(Tooling::Luacheck)?);
        assert_eq!(Tooling::Luaformatter, reverse(Tooling::Luaformatter)?);
        assert_eq!(Tooling::LuauAnalyze, reverse(Tooling::LuauAnalyze)?);
        assert_eq!(Tooling::MadoCheck, reverse(Tooling::MadoCheck)?);
        assert_eq!(Tooling::MagoAnalyze, reverse(Tooling::MagoAnalyze)?);
        assert_eq!(Tooling::MagoAnalyzeFix, reverse(Tooling::MagoAnalyzeFix)?);
        assert_eq!(
            Tooling::MagoAnalyzeFixUnsafe,
            reverse(Tooling::MagoAnalyzeFixUnsafe)?
        );
        assert_eq!(Tooling::MagoFormat, reverse(Tooling::MagoFormat)?);
        assert_eq!(Tooling::MagoLint, reverse(Tooling::MagoLint)?);
        assert_eq!(Tooling::MagoLintFix, reverse(Tooling::MagoLintFix)?);
        assert_eq!(
            Tooling::MagoLintFixUnsafe,
            reverse(Tooling::MagoLintFixUnsafe)?
        );
        assert_eq!(Tooling::Markdownfmt, reverse(Tooling::Markdownfmt)?);
        assert_eq!(Tooling::Markdownlint, reverse(Tooling::Markdownlint)?);
        assert_eq!(
            Tooling::MarkdownlintCli2,
            reverse(Tooling::MarkdownlintCli2)?
        );
        assert_eq!(Tooling::Markuplint, reverse(Tooling::Markuplint)?);
        assert_eq!(Tooling::MbakeFormat, reverse(Tooling::MbakeFormat)?);
        assert_eq!(Tooling::MbakeValidate, reverse(Tooling::MbakeValidate)?);
        assert_eq!(Tooling::MdPadding, reverse(Tooling::MdPadding)?);
        assert_eq!(Tooling::Mdformat, reverse(Tooling::Mdformat)?);
        assert_eq!(Tooling::MdsfFormat, reverse(Tooling::MdsfFormat)?);
        assert_eq!(Tooling::MdsfVerify, reverse(Tooling::MdsfVerify)?);
        assert_eq!(Tooling::Mdslw, reverse(Tooling::Mdslw)?);
        assert_eq!(Tooling::MesonFmt, reverse(Tooling::MesonFmt)?);
        assert_eq!(Tooling::MhLint, reverse(Tooling::MhLint)?);
        assert_eq!(Tooling::MhStyle, reverse(Tooling::MhStyle)?);
        assert_eq!(Tooling::MiseFmt, reverse(Tooling::MiseFmt)?);
        assert_eq!(Tooling::Misspell, reverse(Tooling::Misspell)?);
        assert_eq!(Tooling::MixFormat, reverse(Tooling::MixFormat)?);
        assert_eq!(Tooling::MojoFormat, reverse(Tooling::MojoFormat)?);
        assert_eq!(Tooling::MuonFmt, reverse(Tooling::MuonFmt)?);
        assert_eq!(Tooling::MuonLint, reverse(Tooling::MuonLint)?);
        assert_eq!(Tooling::Mypy, reverse(Tooling::Mypy)?);
        assert_eq!(Tooling::Nasmfmt, reverse(Tooling::Nasmfmt)?);
        assert_eq!(Tooling::Nginxbeautifier, reverse(Tooling::Nginxbeautifier)?);
        assert_eq!(Tooling::Nginxfmt, reverse(Tooling::Nginxfmt)?);
        assert_eq!(Tooling::NickelFormat, reverse(Tooling::NickelFormat)?);
        assert_eq!(Tooling::Nimpretty, reverse(Tooling::Nimpretty)?);
        assert_eq!(Tooling::Nixfmt, reverse(Tooling::Nixfmt)?);
        assert_eq!(Tooling::NixpkgsFmt, reverse(Tooling::NixpkgsFmt)?);
        assert_eq!(Tooling::NomadFmt, reverse(Tooling::NomadFmt)?);
        assert_eq!(Tooling::Nph, reverse(Tooling::Nph)?);
        assert_eq!(Tooling::NpmGroovyLint, reverse(Tooling::NpmGroovyLint)?);
        assert_eq!(Tooling::Nufmt, reverse(Tooling::Nufmt)?);
        assert_eq!(Tooling::Ocamlformat, reverse(Tooling::Ocamlformat)?);
        assert_eq!(Tooling::OcpIndent, reverse(Tooling::OcpIndent)?);
        assert_eq!(Tooling::Odinfmt, reverse(Tooling::Odinfmt)?);
        assert_eq!(Tooling::OelintAdv, reverse(Tooling::OelintAdv)?);
        assert_eq!(Tooling::OpaFmt, reverse(Tooling::OpaFmt)?);
        assert_eq!(Tooling::Ormolu, reverse(Tooling::Ormolu)?);
        assert_eq!(Tooling::Oxfmt, reverse(Tooling::Oxfmt)?);
        assert_eq!(Tooling::Oxlint, reverse(Tooling::Oxlint)?);
        assert_eq!(Tooling::PackerFix, reverse(Tooling::PackerFix)?);
        assert_eq!(Tooling::PackerFmt, reverse(Tooling::PackerFmt)?);
        assert_eq!(Tooling::PackerValidate, reverse(Tooling::PackerValidate)?);
        assert_eq!(Tooling::Pasfmt, reverse(Tooling::Pasfmt)?);
        assert_eq!(Tooling::Perflint, reverse(Tooling::Perflint)?);
        assert_eq!(Tooling::Perltidy, reverse(Tooling::Perltidy)?);
        assert_eq!(Tooling::PgFormat, reverse(Tooling::PgFormat)?);
        assert_eq!(Tooling::PhpCsFixerFix, reverse(Tooling::PhpCsFixerFix)?);
        assert_eq!(Tooling::Phpcbf, reverse(Tooling::Phpcbf)?);
        assert_eq!(Tooling::PhpinsightsFix, reverse(Tooling::PhpinsightsFix)?);
        assert_eq!(Tooling::Pint, reverse(Tooling::Pint)?);
        assert_eq!(Tooling::PklFormat, reverse(Tooling::PklFormat)?);
        assert_eq!(Tooling::Prettier, reverse(Tooling::Prettier)?);
        assert_eq!(Tooling::Prettierd, reverse(Tooling::Prettierd)?);
        assert_eq!(Tooling::PrettyPhp, reverse(Tooling::PrettyPhp)?);
        assert_eq!(Tooling::Prettypst, reverse(Tooling::Prettypst)?);
        assert_eq!(Tooling::PrismaFormat, reverse(Tooling::PrismaFormat)?);
        assert_eq!(Tooling::Proselint, reverse(Tooling::Proselint)?);
        assert_eq!(Tooling::Protolint, reverse(Tooling::Protolint)?);
        assert_eq!(Tooling::Ptop, reverse(Tooling::Ptop)?);
        assert_eq!(Tooling::PugLint, reverse(Tooling::PugLint)?);
        assert_eq!(Tooling::PuppetLint, reverse(Tooling::PuppetLint)?);
        assert_eq!(Tooling::PursTidy, reverse(Tooling::PursTidy)?);
        assert_eq!(Tooling::Purty, reverse(Tooling::Purty)?);
        assert_eq!(Tooling::Pycln, reverse(Tooling::Pycln)?);
        assert_eq!(Tooling::Pycodestyle, reverse(Tooling::Pycodestyle)?);
        assert_eq!(Tooling::Pydoclint, reverse(Tooling::Pydoclint)?);
        assert_eq!(
            Tooling::Pydocstringformatter,
            reverse(Tooling::Pydocstringformatter)?
        );
        assert_eq!(Tooling::Pydocstyle, reverse(Tooling::Pydocstyle)?);
        assert_eq!(Tooling::Pyflakes, reverse(Tooling::Pyflakes)?);
        assert_eq!(Tooling::Pyink, reverse(Tooling::Pyink)?);
        assert_eq!(Tooling::Pylint, reverse(Tooling::Pylint)?);
        assert_eq!(
            Tooling::PymarkdownlntFix,
            reverse(Tooling::PymarkdownlntFix)?
        );
        assert_eq!(Tooling::Pyment, reverse(Tooling::Pyment)?);
        assert_eq!(Tooling::Pyrefly, reverse(Tooling::Pyrefly)?);
        assert_eq!(Tooling::Pyupgrade, reverse(Tooling::Pyupgrade)?);
        assert_eq!(Tooling::Qmlfmt, reverse(Tooling::Qmlfmt)?);
        assert_eq!(Tooling::Qmlformat, reverse(Tooling::Qmlformat)?);
        assert_eq!(Tooling::Qmllint, reverse(Tooling::Qmllint)?);
        assert_eq!(Tooling::QuickLintJs, reverse(Tooling::QuickLintJs)?);
        assert_eq!(Tooling::RacoFmt, reverse(Tooling::RacoFmt)?);
        assert_eq!(Tooling::Reek, reverse(Tooling::Reek)?);
        assert_eq!(Tooling::Refmt, reverse(Tooling::Refmt)?);
        assert_eq!(Tooling::ReformatGherkin, reverse(Tooling::ReformatGherkin)?);
        assert_eq!(Tooling::Refurb, reverse(Tooling::Refurb)?);
        assert_eq!(Tooling::RegalFix, reverse(Tooling::RegalFix)?);
        assert_eq!(Tooling::RegalLint, reverse(Tooling::RegalLint)?);
        assert_eq!(
            Tooling::ReorderPythonImports,
            reverse(Tooling::ReorderPythonImports)?
        );
        assert_eq!(Tooling::RescriptFormat, reverse(Tooling::RescriptFormat)?);
        assert_eq!(Tooling::Revive, reverse(Tooling::Revive)?);
        assert_eq!(Tooling::RocFormat, reverse(Tooling::RocFormat)?);
        assert_eq!(Tooling::Rstfmt, reverse(Tooling::Rstfmt)?);
        assert_eq!(Tooling::Rubocop, reverse(Tooling::Rubocop)?);
        assert_eq!(Tooling::Rubyfmt, reverse(Tooling::Rubyfmt)?);
        assert_eq!(Tooling::RuffCheck, reverse(Tooling::RuffCheck)?);
        assert_eq!(Tooling::RuffFormat, reverse(Tooling::RuffFormat)?);
        assert_eq!(Tooling::Rufo, reverse(Tooling::Rufo)?);
        assert_eq!(Tooling::RumdlCheck, reverse(Tooling::RumdlCheck)?);
        assert_eq!(Tooling::RumdlCheckFix, reverse(Tooling::RumdlCheckFix)?);
        assert_eq!(Tooling::RumdlFmt, reverse(Tooling::RumdlFmt)?);
        assert_eq!(Tooling::RuneFmt, reverse(Tooling::RuneFmt)?);
        assert_eq!(Tooling::Runic, reverse(Tooling::Runic)?);
        assert_eq!(Tooling::Rustfmt, reverse(Tooling::Rustfmt)?);
        assert_eq!(Tooling::Rustfmt2015, reverse(Tooling::Rustfmt2015)?);
        assert_eq!(Tooling::Rustfmt2018, reverse(Tooling::Rustfmt2018)?);
        assert_eq!(Tooling::Rustfmt2021, reverse(Tooling::Rustfmt2021)?);
        assert_eq!(Tooling::Rustfmt2024, reverse(Tooling::Rustfmt2024)?);
        assert_eq!(Tooling::Rustywind, reverse(Tooling::Rustywind)?);
        assert_eq!(Tooling::SaltLint, reverse(Tooling::SaltLint)?);
        assert_eq!(Tooling::Scala, reverse(Tooling::Scala)?);
        assert_eq!(Tooling::Scalafmt, reverse(Tooling::Scalafmt)?);
        assert_eq!(Tooling::Scalariform, reverse(Tooling::Scalariform)?);
        assert_eq!(Tooling::Selene, reverse(Tooling::Selene)?);
        assert_eq!(Tooling::Semistandard, reverse(Tooling::Semistandard)?);
        assert_eq!(Tooling::Shellcheck, reverse(Tooling::Shellcheck)?);
        assert_eq!(Tooling::Shellharden, reverse(Tooling::Shellharden)?);
        assert_eq!(Tooling::Shfmt, reverse(Tooling::Shfmt)?);
        assert_eq!(Tooling::Sleek, reverse(Tooling::Sleek)?);
        assert_eq!(Tooling::SlimLint, reverse(Tooling::SlimLint)?);
        assert_eq!(Tooling::Smlfmt, reverse(Tooling::Smlfmt)?);
        assert_eq!(Tooling::Snakefmt, reverse(Tooling::Snakefmt)?);
        assert_eq!(Tooling::Solhint, reverse(Tooling::Solhint)?);
        assert_eq!(Tooling::SphinxLint, reverse(Tooling::SphinxLint)?);
        assert_eq!(Tooling::SqlFormatter, reverse(Tooling::SqlFormatter)?);
        assert_eq!(Tooling::SqlfluffFix, reverse(Tooling::SqlfluffFix)?);
        assert_eq!(Tooling::SqlfluffFormat, reverse(Tooling::SqlfluffFormat)?);
        assert_eq!(Tooling::SqlfluffLint, reverse(Tooling::SqlfluffLint)?);
        assert_eq!(Tooling::Sqlfmt, reverse(Tooling::Sqlfmt)?);
        assert_eq!(Tooling::Sqlint, reverse(Tooling::Sqlint)?);
        assert_eq!(Tooling::Sqruff, reverse(Tooling::Sqruff)?);
        assert_eq!(Tooling::Squawk, reverse(Tooling::Squawk)?);
        assert_eq!(Tooling::Standardjs, reverse(Tooling::Standardjs)?);
        assert_eq!(Tooling::Standardrb, reverse(Tooling::Standardrb)?);
        assert_eq!(Tooling::StatixCheck, reverse(Tooling::StatixCheck)?);
        assert_eq!(Tooling::StatixFix, reverse(Tooling::StatixFix)?);
        assert_eq!(Tooling::Stylefmt, reverse(Tooling::Stylefmt)?);
        assert_eq!(Tooling::Stylelint, reverse(Tooling::Stylelint)?);
        assert_eq!(Tooling::StylishHaskell, reverse(Tooling::StylishHaskell)?);
        assert_eq!(Tooling::Stylua, reverse(Tooling::Stylua)?);
        assert_eq!(Tooling::SuperhtmlFmt, reverse(Tooling::SuperhtmlFmt)?);
        assert_eq!(Tooling::Svlint, reverse(Tooling::Svlint)?);
        assert_eq!(Tooling::SwiftFormat, reverse(Tooling::SwiftFormat)?);
        assert_eq!(Tooling::Swiftformat, reverse(Tooling::Swiftformat)?);
        assert_eq!(Tooling::Swiftlint, reverse(Tooling::Swiftlint)?);
        assert_eq!(Tooling::Taplo, reverse(Tooling::Taplo)?);
        assert_eq!(Tooling::Tclfmt, reverse(Tooling::Tclfmt)?);
        assert_eq!(Tooling::Tclint, reverse(Tooling::Tclint)?);
        assert_eq!(Tooling::TemplFmt, reverse(Tooling::TemplFmt)?);
        assert_eq!(Tooling::TerraformFmt, reverse(Tooling::TerraformFmt)?);
        assert_eq!(
            Tooling::TerragruntHclfmt,
            reverse(Tooling::TerragruntHclfmt)?
        );
        assert_eq!(Tooling::TexFmt, reverse(Tooling::TexFmt)?);
        assert_eq!(Tooling::Textlint, reverse(Tooling::Textlint)?);
        assert_eq!(Tooling::TextlintFix, reverse(Tooling::TextlintFix)?);
        assert_eq!(Tooling::TlintFormat, reverse(Tooling::TlintFormat)?);
        assert_eq!(Tooling::TofuFmt, reverse(Tooling::TofuFmt)?);
        assert_eq!(Tooling::TombiFormat, reverse(Tooling::TombiFormat)?);
        assert_eq!(Tooling::TombiLint, reverse(Tooling::TombiLint)?);
        assert_eq!(Tooling::TomlSort, reverse(Tooling::TomlSort)?);
        assert_eq!(Tooling::Topiary, reverse(Tooling::Topiary)?);
        assert_eq!(Tooling::Tryceratops, reverse(Tooling::Tryceratops)?);
        assert_eq!(Tooling::TsStandard, reverse(Tooling::TsStandard)?);
        assert_eq!(Tooling::TspFormat, reverse(Tooling::TspFormat)?);
        assert_eq!(Tooling::Tsqllint, reverse(Tooling::Tsqllint)?);
        assert_eq!(
            Tooling::TwigCsFixerCheck,
            reverse(Tooling::TwigCsFixerCheck)?
        );
        assert_eq!(Tooling::TwigCsFixerFix, reverse(Tooling::TwigCsFixerFix)?);
        assert_eq!(Tooling::TwigCsFixerLint, reverse(Tooling::TwigCsFixerLint)?);
        assert_eq!(Tooling::Twigcs, reverse(Tooling::Twigcs)?);
        assert_eq!(Tooling::Txtpbfmt, reverse(Tooling::Txtpbfmt)?);
        assert_eq!(Tooling::Ty, reverse(Tooling::Ty)?);
        assert_eq!(Tooling::Typos, reverse(Tooling::Typos)?);
        assert_eq!(Tooling::Typstfmt, reverse(Tooling::Typstfmt)?);
        assert_eq!(Tooling::Typstyle, reverse(Tooling::Typstyle)?);
        assert_eq!(Tooling::Ufmt, reverse(Tooling::Ufmt)?);
        assert_eq!(Tooling::UiuaFmt, reverse(Tooling::UiuaFmt)?);
        assert_eq!(Tooling::Unimport, reverse(Tooling::Unimport)?);
        assert_eq!(Tooling::Usort, reverse(Tooling::Usort)?);
        assert_eq!(Tooling::VFmt, reverse(Tooling::VFmt)?);
        assert_eq!(Tooling::VacuumLint, reverse(Tooling::VacuumLint)?);
        assert_eq!(Tooling::Verusfmt, reverse(Tooling::Verusfmt)?);
        assert_eq!(Tooling::VerylFmt, reverse(Tooling::VerylFmt)?);
        assert_eq!(Tooling::VhdlStyleGuide, reverse(Tooling::VhdlStyleGuide)?);
        assert_eq!(Tooling::Vint, reverse(Tooling::Vint)?);
        assert_eq!(Tooling::VintNeovim, reverse(Tooling::VintNeovim)?);
        assert_eq!(Tooling::WaFmt, reverse(Tooling::WaFmt)?);
        assert_eq!(Tooling::Wfindent, reverse(Tooling::Wfindent)?);
        assert_eq!(Tooling::WriteGood, reverse(Tooling::WriteGood)?);
        assert_eq!(Tooling::Xmlformat, reverse(Tooling::Xmlformat)?);
        assert_eq!(Tooling::Xmllint, reverse(Tooling::Xmllint)?);
        assert_eq!(Tooling::Xo, reverse(Tooling::Xo)?);
        assert_eq!(Tooling::Xq, reverse(Tooling::Xq)?);
        assert_eq!(Tooling::XqHtml, reverse(Tooling::XqHtml)?);
        assert_eq!(Tooling::Yamlfix, reverse(Tooling::Yamlfix)?);
        assert_eq!(Tooling::Yamlfmt, reverse(Tooling::Yamlfmt)?);
        assert_eq!(Tooling::Yamllint, reverse(Tooling::Yamllint)?);
        assert_eq!(Tooling::Yapf, reverse(Tooling::Yapf)?);
        assert_eq!(Tooling::YardLint, reverse(Tooling::YardLint)?);
        assert_eq!(Tooling::YewFmt, reverse(Tooling::YewFmt)?);
        assert_eq!(Tooling::Yq, reverse(Tooling::Yq)?);
        assert_eq!(Tooling::ZigFmt, reverse(Tooling::ZigFmt)?);
        assert_eq!(Tooling::ZiggyCheck, reverse(Tooling::ZiggyCheck)?);
        assert_eq!(Tooling::ZiggyFmt, reverse(Tooling::ZiggyFmt)?);
        assert_eq!(Tooling::Zprint, reverse(Tooling::Zprint)?);
        assert_eq!(Tooling::Zsweep, reverse(Tooling::Zsweep)?);
        assert_eq!(Tooling::Zuban, reverse(Tooling::Zuban)?);
        assert_eq!(Tooling::ZubanCheck, reverse(Tooling::ZubanCheck)?);
        assert_eq!(Tooling::ZubanMypy, reverse(Tooling::ZubanMypy)?);

        Ok(())
    }
}
