diff --git a/analyzer/codechecker_analyzer/analyzers/analyzer_base.py b/analyzer/codechecker_analyzer/analyzers/analyzer_base.py
index 8d0eb4358f..125b2c68ae 100644
--- a/analyzer/codechecker_analyzer/analyzers/analyzer_base.py
+++ b/analyzer/codechecker_analyzer/analyzers/analyzer_base.py
@@ -17,7 +17,7 @@
 import sys
 import shlex
 
-from typing import Optional
+from typing import List, Optional
 
 from codechecker_analyzer import analyzer_context
 from codechecker_common.logger import get_logger
@@ -25,6 +25,20 @@
 LOG = get_logger('analyzer')
 
 
+class AnalyzerConfig:
+    def __init__(self, option: str, documentation: str, value_type: type):
+        self.option = option
+        self.documentation = documentation
+        self.value_type = value_type
+
+
+class CheckerConfig:
+    def __init__(self, checker: str, option: str, documentation: str):
+        self.checker = checker
+        self.option = option
+        self.documentation = documentation
+
+
 class SourceAnalyzer(metaclass=ABCMeta):
     """
     Base class for different source analyzers.
@@ -138,6 +152,14 @@ def get_analyzer_checkers(cls):
         """
         raise NotImplementedError("Subclasses should implement this!")
 
+    @classmethod
+    def get_analyzer_config(cls) -> List[AnalyzerConfig]:
+        return []
+
+    @classmethod
+    def get_checker_config(cls) -> List[CheckerConfig]:
+        return []
+
     def post_analyze(self, result_handler):
         """
         Run immediately after the analyze function.
diff --git a/analyzer/codechecker_analyzer/analyzers/clangsa/analyzer.py b/analyzer/codechecker_analyzer/analyzers/clangsa/analyzer.py
index 7379c6374a..6ae05f168a 100644
--- a/analyzer/codechecker_analyzer/analyzers/clangsa/analyzer.py
+++ b/analyzer/codechecker_analyzer/analyzers/clangsa/analyzer.py
@@ -121,11 +121,13 @@ class ClangSA(analyzer_base.SourceAnalyzer):
 
     __ctu_autodetection = None
 
-    __additional_analyzer_config = {
-        'cc-verbatim-args-file':
+    __additional_analyzer_config = [
+        analyzer_base.AnalyzerConfig(
+            'cc-verbatim-args-file',
             'A file path containing flags that are forwarded verbatim to the '
-            'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>'
-    }
+            'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>',
+            util.ExistingPath)
+    ]
 
     def __init__(self, cfg_handler, buildaction):
         super().__init__(cfg_handler, buildaction)
@@ -290,7 +292,7 @@ def get_analyzer_checkers(
         return parse_clang_help_page(command, 'CHECKERS:')
 
     @classmethod
-    def get_checker_config(cls) -> List[str]:
+    def get_checker_config(cls) -> List[analyzer_base.CheckerConfig]:
         """
         Return the list of checker config options.
 
@@ -311,10 +313,14 @@ def get_checker_config(cls) -> List[str]:
             if version_info.major_version >= 9:
                 command.append("-analyzer-checker-option-help-developer")
 
-        return parse_clang_help_page(command, 'OPTIONS:')
+        result = []
+        for cfg, doc in parse_clang_help_page(command, 'OPTIONS:'):
+            result.append(analyzer_base.CheckerConfig(*cfg.split(':', 1), doc))
+
+        return result
 
     @classmethod
-    def get_analyzer_config(cls) -> List[Tuple[str, str]]:
+    def get_analyzer_config(cls) -> List[analyzer_base.AnalyzerConfig]:
         """Return the list of analyzer config options."""
         command = [cls.analyzer_binary(), "-cc1"]
 
@@ -323,8 +329,11 @@ def get_analyzer_config(cls) -> List[Tuple[str, str]]:
         command.append("-analyzer-config-help")
 
         native_config = parse_clang_help_page(command, 'OPTIONS:')
+        native_config = map(
+            lambda cfg: analyzer_base.AnalyzerConfig(cfg[0], cfg[1], str),
+            native_config)
 
-        return native_config + list(cls.__additional_analyzer_config.items())
+        return list(native_config) + list(cls.__additional_analyzer_config)
 
     def post_analyze(self, result_handler):
         """
diff --git a/analyzer/codechecker_analyzer/analyzers/clangtidy/analyzer.py b/analyzer/codechecker_analyzer/analyzers/clangtidy/analyzer.py
index cb88a6c7b9..b4e32617db 100644
--- a/analyzer/codechecker_analyzer/analyzers/clangtidy/analyzer.py
+++ b/analyzer/codechecker_analyzer/analyzers/clangtidy/analyzer.py
@@ -256,11 +256,19 @@ class ClangTidy(analyzer_base.SourceAnalyzer):
     # Cache object for get_analyzer_checkers().
     __analyzer_checkers = None
 
-    __additional_analyzer_config = {
-        'cc-verbatim-args-file':
+    __additional_analyzer_config = [
+        analyzer_base.AnalyzerConfig(
+            'cc-verbatim-args-file',
             'A file path containing flags that are forwarded verbatim to the '
-            'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>'
-    }
+            'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>',
+            util.ExistingPath),
+        analyzer_base.AnalyzerConfig(
+            'take-config-from-directory',
+            'The .clang-tidy config file should be taken into account when '
+            'analysis is executed through CodeChecker. Possible values: true, '
+            'false. Default: false',
+            str)
+    ]
 
     @classmethod
     def analyzer_binary(cls):
@@ -334,24 +342,29 @@ def get_analyzer_checkers(cls):
             return []
 
     @classmethod
-    def get_checker_config(cls):
+    def get_checker_config(cls) -> List[analyzer_base.CheckerConfig]:
         """
         Return the checker configuration of the all of the supported checkers.
         """
         try:
-            result = subprocess.check_output(
+            help_page = subprocess.check_output(
                 [cls.analyzer_binary(), "-dump-config", "-checks=*"],
                 env=analyzer_context.get_context()
                 .get_env_for_bin(cls.analyzer_binary()),
                 universal_newlines=True,
                 encoding="utf-8",
                 errors="ignore")
-            return parse_checker_config(result)
         except (subprocess.CalledProcessError, OSError):
             return []
 
+        result = []
+        for cfg, doc in parse_checker_config(help_page):
+            result.append(analyzer_base.CheckerConfig(*cfg.split(':', 1), doc))
+
+        return result
+
     @classmethod
-    def get_analyzer_config(cls):
+    def get_analyzer_config(cls) -> List[analyzer_base.AnalyzerConfig]:
         """
         Return the analyzer configuration with all checkers enabled.
         """
@@ -370,7 +383,11 @@ def get_analyzer_config(cls):
         except (subprocess.CalledProcessError, OSError):
             native_config = []
 
-        return native_config + list(cls.__additional_analyzer_config.items())
+        native_config = map(
+            lambda cfg: analyzer_base.AnalyzerConfig(cfg[0], cfg[1], str),
+            native_config)
+
+        return list(native_config) + list(cls.__additional_analyzer_config)
 
     def get_checker_list(self, config) -> Tuple[List[str], List[str]]:
         """
diff --git a/analyzer/codechecker_analyzer/analyzers/cppcheck/analyzer.py b/analyzer/codechecker_analyzer/analyzers/cppcheck/analyzer.py
index 77cc41a9c6..e2de4fa84c 100644
--- a/analyzer/codechecker_analyzer/analyzers/cppcheck/analyzer.py
+++ b/analyzer/codechecker_analyzer/analyzers/cppcheck/analyzer.py
@@ -11,6 +11,7 @@
 
 from collections import defaultdict
 import sys
+from typing import List
 from packaging.version import Version
 from pathlib import Path
 import os
@@ -299,27 +300,34 @@ def get_analyzer_checkers(cls):
         return []
 
     @classmethod
-    def get_analyzer_config(cls):
+    def get_analyzer_config(cls) -> List[analyzer_base.AnalyzerConfig]:
         """
         Config options for cppcheck.
         """
         return [
-            ("addons", "A list of cppcheck addon files."),
-            ("libraries", "A list of cppcheck library definiton files."),
-            ("platform", "The platform configuration .xml file."),
-            ("inconclusive", "Enable inconclusive reports."),
-            ("cc-verbatim-args-file",
-             "A file path containing flags that are forwarded verbatim to the "
-             "analyzer tool. E.g.: cc-verbatim-args-file=<filepath>")
+            analyzer_base.AnalyzerConfig(
+                "addons",
+                "A list of cppcheck addon files.",
+                str),
+            analyzer_base.AnalyzerConfig(
+                "libraries",
+                "A list of cppcheck library definiton files.",
+                str),
+            analyzer_base.AnalyzerConfig(
+                "platform",
+                "The platform configuration .xml file.",
+                str),
+            analyzer_base.AnalyzerConfig(
+                "inconclusive",
+                "Enable inconclusive reports.",
+                str),
+            analyzer_base.AnalyzerConfig(
+                "cc-verbatim-args-file",
+                "A file path containing flags that are forwarded verbatim to "
+                "the analyzer tool. E.g.: cc-verbatim-args-file=<filepath>",
+                util.ExistingPath)
         ]
 
-    @classmethod
-    def get_checker_config(cls):
-        """
-        TODO add config options for cppcheck checkers.
-        """
-        return []
-
     def post_analyze(self, result_handler):
         """
         Post process the reuslts after the analysis.
diff --git a/analyzer/codechecker_analyzer/analyzers/gcc/analyzer.py b/analyzer/codechecker_analyzer/analyzers/gcc/analyzer.py
index 6e5e4808c7..caf2d6d444 100644
--- a/analyzer/codechecker_analyzer/analyzers/gcc/analyzer.py
+++ b/analyzer/codechecker_analyzer/analyzers/gcc/analyzer.py
@@ -5,6 +5,7 @@
 #  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 # -------------------------------------------------------------------------
+from typing import List
 from packaging.version import Version
 import shlex
 import subprocess
@@ -124,25 +125,19 @@ def get_analyzer_checkers(cls):
         return []
 
     @classmethod
-    def get_analyzer_config(cls):
+    def get_analyzer_config(cls) -> List[analyzer_base.AnalyzerConfig]:
         """
         Config options for gcc.
         """
         # TODO
         return [
-            ('cc-verbatim-args-file',
-             'A file path containing flags that are forwarded verbatim to the '
-             'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>')
+            analyzer_base.AnalyzerConfig(
+                'cc-verbatim-args-file',
+                'A file path containing flags that are forwarded verbatim to '
+                'the analyzer tool. E.g.: cc-verbatim-args-file=<filepath>',
+                util.ExistingPath)
         ]
 
-    @classmethod
-    def get_checker_config(cls):
-        """
-        TODO add config options for gcc checkers.
-        """
-        # TODO
-        return []
-
     def post_analyze(self, result_handler: GccResultHandler):
         """
         Post process the reuslts after the analysis.
diff --git a/analyzer/codechecker_analyzer/analyzers/infer/analyzer.py b/analyzer/codechecker_analyzer/analyzers/infer/analyzer.py
index 5d0c3ca0e5..a94c782801 100644
--- a/analyzer/codechecker_analyzer/analyzers/infer/analyzer.py
+++ b/analyzer/codechecker_analyzer/analyzers/infer/analyzer.py
@@ -15,6 +15,7 @@
 import json
 from pathlib import Path
 import sys
+from typing import List
 
 from codechecker_common import util
 from codechecker_common.logger import get_logger
@@ -138,23 +139,18 @@ def get_analyzer_checkers(cls):
         return []
 
     @classmethod
-    def get_analyzer_config(cls):
+    def get_analyzer_config(cls) -> List[analyzer_base.AnalyzerConfig]:
         """
         Config options for infer.
         """
         return [
-            ('cc-verbatim-args-file',
-             'A file path containing flags that are forwarded verbatim to the '
-             'analyzer tool. E.g.: cc-verbatim-args-file=<filepath>')
+            analyzer_base.AnalyzerConfig(
+                'cc-verbatim-args-file',
+                'A file path containing flags that are forwarded verbatim to '
+                'the analyzer tool. E.g.: cc-verbatim-args-file=<filepath>',
+                util.ExistingPath)
         ]
 
-    @classmethod
-    def get_checker_config(cls):
-        """
-        Config options for infer checkers.
-        """
-        return []
-
     def analyze(self, analyzer_cmd, res_handler, proc_callback=None, env=None):
 
         env = analyzer_context.get_context().get_env_for_bin(
diff --git a/analyzer/codechecker_analyzer/arg.py b/analyzer/codechecker_analyzer/arg.py
index 22c5469b39..7899c3ff29 100644
--- a/analyzer/codechecker_analyzer/arg.py
+++ b/analyzer/codechecker_analyzer/arg.py
@@ -14,10 +14,10 @@
 import re
 
 
-AnalyzerConfig = collections.namedtuple(
-    'AnalyzerConfig', ["analyzer", "option", "value"])
-CheckerConfig = collections.namedtuple(
-    "CheckerConfig", ["analyzer", "checker", "option", "value"])
+AnalyzerConfigArg = collections.namedtuple(
+    "AnalyzerConfigArg", ["analyzer", "option", "value"])
+CheckerConfigArg = collections.namedtuple(
+    "CheckerConfigArg", ["analyzer", "checker", "option", "value"])
 AnalyzerBinary = collections.namedtuple(
     "AnalyzerBinary", ["analyzer", "path"])
 
@@ -106,7 +106,7 @@ def existing_abspath(path: str) -> str:
     return path
 
 
-def analyzer_config(arg: str) -> AnalyzerConfig:
+def analyzer_config(arg: str) -> AnalyzerConfigArg:
     """
     This function can be used at "type" argument of argparse.add_argument().
     It checks the format of --analyzer-config flag:
@@ -120,11 +120,11 @@ def analyzer_config(arg: str) -> AnalyzerConfig:
             f"Analyzer option in wrong format: {arg}, should be "
             "<analyzer>:<option>=<value>")
 
-    return AnalyzerConfig(
+    return AnalyzerConfigArg(
         m.group("analyzer"), m.group("option"), m.group("value"))
 
 
-def checker_config(arg: str) -> CheckerConfig:
+def checker_config(arg: str) -> CheckerConfigArg:
     """
     This function can be used at "type" argument of argparse.add_argument().
     It checks the format of --checker-config flag:
@@ -139,7 +139,7 @@ def checker_config(arg: str) -> CheckerConfig:
             f"Checker option in wrong format: {arg}, should be "
             "<analyzer>:<checker>:<option>=<value>")
 
-    return CheckerConfig(
+    return CheckerConfigArg(
         m.group("analyzer"), m.group("checker"),
         m.group("option"), m.group("value"))
 
diff --git a/analyzer/codechecker_analyzer/cli/analyze.py b/analyzer/codechecker_analyzer/cli/analyze.py
index 4a05538478..c65566af9d 100644
--- a/analyzer/codechecker_analyzer/cli/analyze.py
+++ b/analyzer/codechecker_analyzer/cli/analyze.py
@@ -25,7 +25,7 @@
 from codechecker_analyzer.analyzers import analyzer_types, clangsa
 from codechecker_analyzer.arg import \
     OrderedCheckersAction, OrderedConfigAction, existing_abspath, \
-    analyzer_config, checker_config, AnalyzerConfig, CheckerConfig
+    analyzer_config, checker_config, AnalyzerConfigArg, CheckerConfigArg
 
 from codechecker_analyzer.buildlog import log_parser
 
@@ -861,85 +861,99 @@ def add_arguments_to_parser(parser):
         func=main, func_process_config_file=cmd_config.process_config_file)
 
 
-def is_analyzer_config_valid(analyzer_conf: List[AnalyzerConfig]) -> bool:
+def is_analyzer_config_valid(
+    analyzer_config_args: List[AnalyzerConfigArg]
+) -> bool:
     """
     Ensure that the analyzer_config parameter is set to a valid value
     by verifying if it belongs to the set of allowed values.
     """
-    wrong_configs = []
+    wrong_config_messages = []
     supported_analyzers = analyzer_types.supported_analyzers
 
-    for cfg in analyzer_conf:
-        if cfg.analyzer not in supported_analyzers:
-            wrong_configs.append((cfg.analyzer, None))
+    analyzer_configs = {
+        analyzer_name: analyzer_class.get_analyzer_config()
+        for analyzer_name, analyzer_class
+        in supported_analyzers.items()
+    }
+
+    for cfg_arg in analyzer_config_args:
+        if cfg_arg.analyzer not in supported_analyzers:
+            wrong_config_messages.append(
+                f"Invalid argument to --analyzer-config: '{cfg_arg.analyzer}' "
+                f"is not a supported analyzer. Supported analyzers are: "
+                f"{', '.join(a for a in supported_analyzers)}.")
             continue
 
-        analyzer_class = supported_analyzers[cfg.analyzer]
-        analyzer_name = analyzer_class.ANALYZER_NAME
-        analyzers = [analyzer[0] for analyzer in
-                     analyzer_class.get_analyzer_config()]
-
-        # Make sure "[clang-tidy] Allow to override checker list #3203" works
-        if analyzer_name == 'clang-tidy':
-            analyzers.append('take-config-from-directory')
-
-        if cfg.analyzer == analyzer_name and cfg.option not in analyzers:
-            wrong_configs.append((analyzer_name, cfg.option))
-
-    if wrong_configs:
-        for analyzer_name, option in wrong_configs:
-            if option is None:
-                LOG.error(
-                    f"Invalid argument to --analyzer-config: {analyzer_name} "
-                    f"is not a supported analyzer. Supported analyzers are: "
-                    f"{', '.join(a for a in supported_analyzers)}.")
-            else:
-                LOG.error(
-                    f"Invalid argument to --analyzer-config: {analyzer_name} "
-                    f"has no config named {option}. Use the 'CodeChecker "
-                    f"analyzers --analyzer-config {analyzer_name}' command to "
-                    f"see available configs.")
+        analyzer_cfg = next(
+            (x for x in analyzer_configs[cfg_arg.analyzer]
+             if x.option == cfg_arg.option),
+            None)
+
+        if analyzer_cfg is None:
+            wrong_config_messages.append(
+                f"Invalid argument to --analyzer-config: {cfg_arg.analyzer} "
+                f"has no config named '{cfg_arg.option}'. Use the "
+                f"'CodeChecker analyzers --analyzer-config "
+                f"{cfg_arg.analyzer}' command to see available configs.")
+        else:
+            try:
+                analyzer_cfg.value_type(cfg_arg.value)
+            except Exception as ex:
+                wrong_config_messages.append(
+                    f"Invalid value to --analyzer-config: "
+                    f"'{cfg_arg.analyzer}:{cfg_arg.option}={cfg_arg.value}'. "
+                    f"{ex}")
+
+    if wrong_config_messages:
+        for wrong_config_message in wrong_config_messages:
+            LOG.error(wrong_config_message)
 
         return False
 
     return True
 
 
-def is_checker_config_valid(checker_conf: List[CheckerConfig]) -> bool:
+def is_checker_config_valid(
+    checker_config_args: List[CheckerConfigArg]
+) -> bool:
     """
     Ensure that the checker_config parameter is set to a valid value
     by verifying if it belongs to the set of allowed values.
     """
-    wrong_configs = []
+    wrong_config_messages = []
     supported_analyzers = analyzer_types.supported_analyzers
 
-    for cfg in checker_conf:
-        if cfg.analyzer not in supported_analyzers:
-            wrong_configs.append((cfg.analyzer, None))
+    checker_configs = {
+        analyzer_name: analyzer_class.get_checker_config()
+        for analyzer_name, analyzer_class
+        in supported_analyzers.items()
+    }
+
+    for cfg_arg in checker_config_args:
+        if cfg_arg.analyzer not in supported_analyzers:
+            wrong_config_messages.append(
+                f"Invalid argument to --checker-config: '{cfg_arg.analyzer}' "
+                f"is not a supported analyzer. Supported analyzers are: "
+                f"{', '.join(a for a in supported_analyzers)}.")
             continue
 
-        analyzer_class = supported_analyzers[cfg.analyzer]
-        analyzer_name = analyzer_class.ANALYZER_NAME
-        checker_conf_opt = f"{cfg.checker}:{cfg.option}"
-        checkers = [checker[0] for checker in
-                    analyzer_class.get_checker_config()]
-
-        if cfg.analyzer == analyzer_name and checker_conf_opt not in checkers:
-            wrong_configs.append((analyzer_name, checker_conf_opt))
-
-    if wrong_configs:
-        for analyzer_name, conf_opt in wrong_configs:
-            if conf_opt is None:
-                LOG.error(
-                    f"Invalid argument to --checker-config: {analyzer_name} "
-                    f"is not a supported analyzer. Supported analyzers are: "
-                    f"{', '.join(a for a in supported_analyzers)}.")
-            else:
-                LOG.error(
-                    f"Invalid argument to --checker-config: invalid checker "
-                    f"and/or checker option '{conf_opt}' for {analyzer_name}. "
-                    f"Use the 'CodeChecker checkers --checker-config' command "
-                    f"to see available checkers.")
+        checker_cfg = next(
+            (x for x in checker_configs[cfg_arg.analyzer]
+             if x.checker == cfg_arg.checker and x.option == cfg_arg.option),
+            None)
+
+        if checker_cfg is None:
+            wrong_config_messages.append(
+                f"Invalid argument to --checker-config: invalid checker "
+                f"'{cfg_arg.checker}' and/or checker option "
+                f"'{cfg_arg.option}' for {cfg_arg.analyzer}. Use the "
+                f"'CodeChecker checkers --checker-config' command to see "
+                f"available checker options.")
+
+    if wrong_config_messages:
+        for wrong_config_message in wrong_config_messages:
+            LOG.error(wrong_config_message)
 
         return False
 
diff --git a/analyzer/codechecker_analyzer/cli/analyzers.py b/analyzer/codechecker_analyzer/cli/analyzers.py
index 468ce0943f..f46b5fa8ed 100644
--- a/analyzer/codechecker_analyzer/cli/analyzers.py
+++ b/analyzer/codechecker_analyzer/cli/analyzers.py
@@ -173,7 +173,9 @@ def uglify(text):
                         "be the case, try to update your analyzer or check "
                         "whether CodeChecker found the intended binary.")
 
-        rows = [(':'.join((analyzer_name, c[0])), c[1]) for c in configs]
+        rows = [
+            (':'.join((analyzer_name, c.option)), c.documentation)
+            for c in configs]
 
         print(twodim.to_str(args.output_format, header, rows))
 
diff --git a/analyzer/codechecker_analyzer/cli/checkers.py b/analyzer/codechecker_analyzer/cli/checkers.py
index 09dcab9535..cbe393925d 100644
--- a/analyzer/codechecker_analyzer/cli/checkers.py
+++ b/analyzer/codechecker_analyzer/cli/checkers.py
@@ -551,8 +551,11 @@ def __print_checker_config(args: argparse.Namespace):
                 analyzer_failures.append(analyzer)
                 continue
 
-        rows.extend((':'.join((analyzer, c[0])), c[1]) if 'details' in args
-                    else (':'.join((analyzer, c[0])),) for c in configs)
+        rows.extend(
+            (f'{analyzer}:{c.checker}:{c.option}', c.documentation)
+            if 'details' in args
+            else (f'{analyzer}:{c.checker}:{c.option}',)
+            for c in configs)
 
     if rows:
         print(twodim.to_str(args.output_format, header, rows))
diff --git a/analyzer/tests/unit/test_checker_handling.py b/analyzer/tests/unit/test_checker_handling.py
index 8ef62a39f5..a9ad38e57f 100644
--- a/analyzer/tests/unit/test_checker_handling.py
+++ b/analyzer/tests/unit/test_checker_handling.py
@@ -24,7 +24,7 @@
 from codechecker_analyzer.analyzers.config_handler import CheckerState
 from codechecker_analyzer.analyzers.clangtidy.config_handler \
     import ClangTidyConfigHandler
-from codechecker_analyzer.arg import AnalyzerConfig, CheckerConfig, \
+from codechecker_analyzer.arg import AnalyzerConfigArg, CheckerConfigArg, \
     analyzer_config
 from codechecker_analyzer.cli.analyze import \
     is_analyzer_config_valid, is_checker_config_valid
@@ -663,26 +663,26 @@ def test_analyze_wrong_parameters(self):
         --analyzer-config or --checker-config parameter is specified.
         """
 
-        analyzer_cfg_valid = [AnalyzerConfig(
+        analyzer_cfg_valid = [AnalyzerConfigArg(
             'clangsa', 'faux-bodies', 'false')]
-        checker_cfg_valid = [CheckerConfig(
+        checker_cfg_valid = [CheckerConfigArg(
             'clang-tidy', 'performance-unnecessary-value-param',
             'IncludeStyle', 'false')]
 
         self.assertTrue(is_analyzer_config_valid(analyzer_cfg_valid))
         self.assertTrue(is_checker_config_valid(checker_cfg_valid))
 
-        analyzer_cfg_invalid_analyzer = [AnalyzerConfig(
+        analyzer_cfg_invalid_analyzer = [AnalyzerConfigArg(
             'asd', 'faux-bodies', 'false')]
-        analyzer_cfg_invalid_conf = [AnalyzerConfig(
+        analyzer_cfg_invalid_conf = [AnalyzerConfigArg(
             'clangsa', 'asd', 'false')]
-        checker_cfg_invalid_analyzer = [CheckerConfig(
+        checker_cfg_invalid_analyzer = [CheckerConfigArg(
             'asd', 'performance-unnecessary-value-param',
             'IncludeStyle', 'false')]
-        checker_cfg_invalid_checker = [CheckerConfig(
+        checker_cfg_invalid_checker = [CheckerConfigArg(
             'clang-tidy', 'asd',
             'IncludeStyle', 'false')]
-        checker_cfg_invalid_checker_option = [CheckerConfig(
+        checker_cfg_invalid_checker_option = [CheckerConfigArg(
             'clang-tidy', 'performance-unnecessary-value-param',
             'asd', 'false')]
 
diff --git a/codechecker_common/util.py b/codechecker_common/util.py
index a2865cc2dc..a363081b7b 100644
--- a/codechecker_common/util.py
+++ b/codechecker_common/util.py
@@ -14,6 +14,7 @@
 import shlex
 import yaml
 import os
+import pathlib
 from typing import List, TextIO
 
 import portalocker
@@ -183,3 +184,16 @@ def load_args_from_file(filepath: str) -> List[str]:
             replace_env_var(filepath),
             f.read().strip())
         return shlex.split(content)
+
+
+# TODO: This class is used for checking if a path exists. This class should
+# inherit from pathlib.Path, however it is not possible before Python 3.12 due
+# to a bug:
+# https://stackoverflow.com/questions/61689391/error-with-simple-subclassing-
+# of-pathlib-path-no-flavour-attribute
+class ExistingPath:
+    def __init__(self, *pathsegments):
+        path = pathlib.Path(*pathsegments)
+
+        if not path.exists():
+            raise FileNotFoundError(f"File does not exist: {path.absolute()}")