Index: docs/clang-tidy/checks/readability-identifier-naming.rst
===================================================================
--- docs/clang-tidy/checks/readability-identifier-naming.rst
+++ docs/clang-tidy/checks/readability-identifier-naming.rst
@@ -5,14 +5,1867 @@
 
 Checks for identifiers naming style mismatch.
 
-This check will try to enforce coding guidelines on the identifiers naming.
-It supports `lower_case`, `UPPER_CASE`, `camelBack` and `CamelCase` casing and
-tries to convert from one to another if a mismatch is detected.
+This check will try to enforce coding guidelines on the identifiers naming. It
+supports one the following casing types and tries to convert from one to
+another if a mismatch is detected
 
-It also supports a fixed prefix and suffix that will be prepended or
-appended to the identifiers, regardless of the casing.
+Casing types inclde:
+
+ - ``lower_case``,
+ - ``UPPER_CASE``,
+ - ``camelBack``,
+ - ``CamelCase``,
+ - ``camel_Snake_Back``,
+ - ``Camel_Snake_Case``,
+ - ``aNy_CasE``.
+
+It also supports a fixed prefix and suffix that will be prepended or appended
+to the identifiers, regardless of the casing.
 
 Many configuration options are available, in order to be able to create
-different rules for different kind of identifier. In general, the
-rules are falling back to a more generic rule if the specific case is not
-configured.
+different rules for different kinds of identifier. In general, the rules are
+falling back to a more generic rule if the specific case is not configured.
+
+Options
+-------
+
+.. option:: AbstractClassCase
+
+    When defined, the checker will check abstract class names conform to the
+    selected casing.
+
+.. option:: AbstractClassPrefix
+
+    When defined, the checker will check abstract class names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: AbstractClassSuffix
+
+    When defined, the checker will check abstract class names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - AbstractClassCase of ``lower_case``
+   - AbstractClassPrefix of ``pre_``
+   - AbstractClassSuffix of ``_post``
+
+Identifies and/or transforms abstract class names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class ABSTRACT_CLASS {
+    public:
+      ABSTRACT_CLASS();
+    };
+
+After:
+
+.. code-block:: c++
+
+    class abstract_class {
+    public:
+      pre_abstract_class_post();
+    };
+
+.. option:: ClassCase
+
+    When defined, the checker will check class names conform to the
+    selected casing.
+
+.. option:: ClassPrefix
+
+    When defined, the checker will check class names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ClassSuffix
+
+    When defined, the checker will check class names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ClassCase of ``lower_case``
+   - ClassPrefix of ``pre_``
+   - ClassSuffix of ``_post``
+
+Identifies and/or transforms class names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      FOO();
+      ~FOO();
+    };
+
+After:
+
+.. code-block:: c++
+
+    class pre_foo_post {
+    public:
+      pre_foo_post();
+      ~pre_foo_post();
+    };
+
+.. option:: ClassConstantCase
+
+    When defined, the checker will check class constant names conform to the
+    selected casing.
+
+.. option:: ClassConstantPrefix
+
+    When defined, the checker will check class constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ClassConstantSuffix
+
+    When defined, the checker will check class constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ClassConstantCase of ``lower_case``
+   - ClassConstantPrefix of ``pre_``
+   - ClassConstantSuffix of ``_post``
+
+Identifies and/or transforms class constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      static const int CLASS_CONSTANT;
+    };
+
+After:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      static const int pre_class_constant_post;
+    };
+
+.. option:: ClassMemberCase
+
+    When defined, the checker will check class member names conform to the
+    selected casing.
+
+.. option:: ClassMemberPrefix
+
+    When defined, the checker will check class member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ClassMemberSuffix
+
+    When defined, the checker will check class member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ClassMemberCase of ``lower_case``
+   - ClassMemberPrefix of ``pre_``
+   - ClassMemberSuffix of ``_post``
+
+Identifies and/or transforms class member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      static int CLASS_CONSTANT;
+    };
+
+After:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      static int pre_class_constant_post;
+    };
+
+.. option:: ClassMethodCase
+
+    When defined, the checker will check class method names conform to the
+    selected casing.
+
+.. option:: ClassMethodPrefix
+
+    When defined, the checker will check class method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ClassMethodSuffix
+
+    When defined, the checker will check class method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ClassMethodCase of ``lower_case``
+   - ClassMethodPrefix of ``pre_``
+   - ClassMethodSuffix of ``_post``
+
+Identifies and/or transforms class method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      int CLASS_MEMBER();
+    };
+
+After:
+
+.. code-block:: c++
+
+    class FOO {
+    public:
+      int pre_class_member_post();
+    };
+
+.. option:: ConstantCase
+
+    When defined, the checker will check constant names conform to the
+    selected casing.
+
+.. option:: ConstantPrefix
+
+    When defined, the checker will check constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstantSuffix
+
+    When defined, the checker will check constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstantCase of ``lower_case``
+   - ConstantPrefix of ``pre_``
+   - ConstantSuffix of ``_post``
+
+Identifies and/or transforms constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void function() { unsigned const MyConst_array[] = {1, 2, 3}; }
+
+After:
+
+.. code-block:: c++
+
+    void function() { unsigned const pre_myconst_array_post[] = {1, 2, 3}; }
+
+.. option:: ConstantMemberCase
+
+    When defined, the checker will check constant member names conform to the
+    selected casing.
+
+.. option:: ConstantMemberPrefix
+
+    When defined, the checker will check constant member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstantMemberSuffix
+
+    When defined, the checker will check constant member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstantMemberCase of ``lower_case``
+   - ConstantMemberPrefix of ``pre_``
+   - ConstantMemberSuffix of ``_post``
+
+Identifies and/or transforms constant member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+      char const MY_ConstMember_string[4] = "123";
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+      char const pre_my_constmember_string_post[4] = "123";
+    }
+
+.. option:: ConstantParameterCase
+
+    When defined, the checker will check constant parameter names conform to the
+    selected casing.
+
+.. option:: ConstantParameterPrefix
+
+    When defined, the checker will check constant parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstantParameterSuffix
+
+    When defined, the checker will check constant parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstantParameterCase of ``lower_case``
+   - ConstantParameterPrefix of ``pre_``
+   - ConstantParameterSuffix of ``_post``
+
+Identifies and/or transforms constant parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+
+After:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int PARAMETER_1, int const pre_const_parameter_post);
+
+.. option:: ConstantPointerParameterCase
+
+    When defined, the checker will check constant pointer parameter names conform to the
+    selected casing.
+
+.. option:: ConstantPointerParameterPrefix
+
+    When defined, the checker will check constant pointer parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstantPointerParameterSuffix
+
+    When defined, the checker will check constant pointer parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstantPointerParameterCase of ``lower_case``
+   - ConstantPointerParameterPrefix of ``pre_``
+   - ConstantPointerParameterSuffix of ``_post``
+
+Identifies and/or transforms constant pointer parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int const *CONST_parameter);
+
+After:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int const *pre_const_parameter_post);
+
+.. option:: ConstexprFunctionCase
+
+    When defined, the checker will check constexpr function names conform to the
+    selected casing.
+
+.. option:: ConstexprFunctionPrefix
+
+    When defined, the checker will check constexpr function names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstexprFunctionSuffix
+
+    When defined, the checker will check constexpr function names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstexprFunctionCase of ``lower_case``
+   - ConstexprFunctionPrefix of ``pre_``
+   - ConstexprFunctionSuffix of ``_post``
+
+Identifies and/or transforms constexpr function names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    constexpr int CE_function() { return 3; }
+
+After:
+
+.. code-block:: c++
+
+    constexpr int pre_ce_function_post() { return 3; }
+
+.. option:: ConstexprMethodCase
+
+    When defined, the checker will check constexpr method names conform to the
+    selected casing.
+
+.. option:: ConstexprMethodPrefix
+
+    When defined, the checker will check constexpr method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstexprMethodSuffix
+
+    When defined, the checker will check constexpr method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstexprMethodCase of ``lower_case``
+   - ConstexprMethodPrefix of ``pre_``
+   - ConstexprMethodSuffix of ``_post``
+
+Identifies and/or transforms constexpr method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      constexpr int CST_expr_Method() { return 2; }
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      constexpr int pre_cst_expr_method_post() { return 2; }
+    }
+
+.. option:: ConstexprVariableCase
+
+    When defined, the checker will check constexpr variable names conform to the
+    selected casing.
+
+.. option:: ConstexprVariablePrefix
+
+    When defined, the checker will check constexpr variable names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ConstexprVariableSuffix
+
+    When defined, the checker will check constexpr variable names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ConstexprVariableCase of ``lower_case``
+   - ConstexprVariablePrefix of ``pre_``
+   - ConstexprVariableSuffix of ``_post``
+
+Identifies and/or transforms constexpr variable names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    constexpr int ConstExpr_variable = MyConstant;
+
+After:
+
+.. code-block:: c++
+
+    constexpr int pre_constexpr_variable_post = MyConstant;
+
+.. option:: EnumCase
+
+    When defined, the checker will check enumeration names conform to the
+    selected casing.
+
+.. option:: EnumPrefix
+
+    When defined, the checker will check enumeration names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: EnumSuffix
+
+    When defined, the checker will check enumeration names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - EnumCase of ``lower_case``
+   - EnumPrefix of ``pre_``
+   - EnumSuffix of ``_post``
+
+Identifies and/or transforms enumeration names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    enum FOO { One, Two, Three };
+
+After:
+
+.. code-block:: c++
+
+    enum pre_foo_post { One, Two, Three };
+
+.. option:: EnumConstantCase
+
+    When defined, the checker will check enumeration constant names conform to the
+    selected casing.
+
+.. option:: EnumConstantPrefix
+
+    When defined, the checker will check enumeration constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: EnumConstantSuffix
+
+    When defined, the checker will check enumeration constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - EnumConstantCase of ``lower_case``
+   - EnumConstantPrefix of ``pre_``
+   - EnumConstantSuffix of ``_post``
+
+Identifies and/or transforms enumeration constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    enum FOO { One, Two, Three };
+
+After:
+
+.. code-block:: c++
+
+    enum FOO { pre_One_post, pre_Two_post, pre_Three_post };
+
+.. option:: FunctionCase
+
+    When defined, the checker will check function names conform to the
+    selected casing.
+
+.. option:: FunctionPrefix
+
+    When defined, the checker will check function names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: FunctionSuffix
+
+    When defined, the checker will check function names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - FunctionCase of ``lower_case``
+   - FunctionPrefix of ``pre_``
+   - FunctionSuffix of ``_post``
+
+Identifies and/or transforms function names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    char MY_Function_string();
+
+After:
+
+.. code-block:: c++
+
+    char pre_my_function_string_post();
+
+.. option:: GlobalConstantCase
+
+    When defined, the checker will check global constant names conform to the
+    selected casing.
+
+.. option:: GlobalConstantPrefix
+
+    When defined, the checker will check global constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: GlobalConstantSuffix
+
+    When defined, the checker will check global constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - GlobalConstantCase of ``lower_case``
+   - GlobalConstantPrefix of ``pre_``
+   - GlobalConstantSuffix of ``_post``
+
+Identifies and/or transforms global constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    unsigned const MyConstGlobal_array[] = {1, 2, 3};
+
+After:
+
+.. code-block:: c++
+
+    unsigned const pre_myconstglobal_array_post[] = {1, 2, 3};
+
+.. option:: GlobalConstantPointerCase
+
+    When defined, the checker will check global constant pointer names conform to the
+    selected casing.
+
+.. option:: GlobalConstantPointerPrefix
+
+    When defined, the checker will check global constant pointer names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: GlobalConstantPointerSuffix
+
+    When defined, the checker will check global constant pointer names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - GlobalConstantPointerCase of ``lower_case``
+   - GlobalConstantPointerPrefix of ``pre_``
+   - GlobalConstantPointerSuffix of ``_post``
+
+Identifies and/or transforms global constant pointer names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    int *const MyConstantGlobalPointer = nullptr;
+
+After:
+
+.. code-block:: c++
+
+    int *const pre_myconstantglobalpointer_post = nullptr;
+
+.. option:: GlobalFunctionCase
+
+    When defined, the checker will check global function names conform to the
+    selected casing.
+
+.. option:: GlobalFunctionPrefix
+
+    When defined, the checker will check global function names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: GlobalFunctionSuffix
+
+    When defined, the checker will check global function names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - GlobalFunctionCase of ``lower_case``
+   - GlobalFunctionPrefix of ``pre_``
+   - GlobalFunctionSuffix of ``_post``
+
+Identifies and/or transforms global function names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+
+After:
+
+.. code-block:: c++
+
+    void pre_global_function_post(int PARAMETER_1, int const CONST_parameter);
+
+.. option:: GlobalPointerCase
+
+    When defined, the checker will check global pointer names conform to the
+    selected casing.
+
+.. option:: GlobalPointerPrefix
+
+    When defined, the checker will check global pointer names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: GlobalPointerSuffix
+
+    When defined, the checker will check global pointer names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - GlobalPointerCase of ``lower_case``
+   - GlobalPointerPrefix of ``pre_``
+   - GlobalPointerSuffix of ``_post``
+
+Identifies and/or transforms global pointer names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    int *GLOBAL3;
+
+After:
+
+.. code-block:: c++
+
+    int *pre_global3_post;
+
+.. option:: GlobalVariableCase
+
+    When defined, the checker will check global variable names conform to the
+    selected casing.
+
+.. option:: GlobalVariablePrefix
+
+    When defined, the checker will check global variable names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: GlobalVariableSuffix
+
+    When defined, the checker will check global variable names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - GlobalVariableCase of ``lower_case``
+   - GlobalVariablePrefix of ``pre_``
+   - GlobalVariableSuffix of ``_post``
+
+Identifies and/or transforms global variable names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    int GLOBAL3;
+
+After:
+
+.. code-block:: c++
+
+    int pre_global3_post;
+
+.. option:: InlineNamespaceCase
+
+    When defined, the checker will check inline namespaces names conform to the
+    selected casing.
+
+.. option:: InlineNamespacePrefix
+
+    When defined, the checker will check inline namespaces names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: InlineNamespaceSuffix
+
+    When defined, the checker will check inline namespaces names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - InlineNamespaceCase of ``lower_case``
+   - InlineNamespacePrefix of ``pre_``
+   - InlineNamespaceSuffix of ``_post``
+
+Identifies and/or transforms inline namespaces names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    namespace FOO_NS {
+    inline namespace InlineNamespace {
+    ...
+    }
+    } // namespace FOO_NS
+
+After:
+
+.. code-block:: c++
+
+    namespace FOO_NS {
+    inline namespace pre_inlinenamespace_post {
+    ...
+    }
+    } // namespace FOO_NS
+
+.. option:: LocalConstantCase
+
+    When defined, the checker will check local constant names conform to the
+    selected casing.
+
+.. option:: LocalConstantPrefix
+
+    When defined, the checker will check local constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: LocalConstantSuffix
+
+    When defined, the checker will check local constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - LocalConstantCase of ``lower_case``
+   - LocalConstantPrefix of ``pre_``
+   - LocalConstantSuffix of ``_post``
+
+Identifies and/or transforms local constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void foo() { int const local_Constant = 3; }
+
+After:
+
+.. code-block:: c++
+
+    void foo() { int const pre_local_constant_post = 3; }
+
+.. option:: LocalConstantPointerCase
+
+    When defined, the checker will check local constant pointer names conform to the
+    selected casing.
+
+.. option:: LocalConstantPointerPrefix
+
+    When defined, the checker will check local constant pointer names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: LocalConstantPointerSuffix
+
+    When defined, the checker will check local constant pointer names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - LocalConstantPointerCase of ``lower_case``
+   - LocalConstantPointerPrefix of ``pre_``
+   - LocalConstantPointerSuffix of ``_post``
+
+Identifies and/or transforms local constant pointer names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void foo() { int const *local_Constant = 3; }
+
+After:
+
+.. code-block:: c++
+
+    void foo() { int const *pre_local_constant_post = 3; }
+
+.. option:: LocalPointerCase
+
+    When defined, the checker will check local pointer names conform to the
+    selected casing.
+
+.. option:: LocalPointerPrefix
+
+    When defined, the checker will check local pointer names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: LocalPointerSuffix
+
+    When defined, the checker will check local pointer names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - LocalPointerCase of ``lower_case``
+   - LocalPointerPrefix of ``pre_``
+   - LocalPointerSuffix of ``_post``
+
+Identifies and/or transforms local pointer names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void foo() { int *local_Constant; }
+
+After:
+
+.. code-block:: c++
+
+    void foo() { int *pre_local_constant_post; }
+
+.. option:: LocalVariableCase
+
+    When defined, the checker will check local variable names conform to the
+    selected casing.
+
+.. option:: LocalVariablePrefix
+
+    When defined, the checker will check local variable names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: LocalVariableSuffix
+
+    When defined, the checker will check local variable names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - LocalVariableCase of ``lower_case``
+   - LocalVariablePrefix of ``pre_``
+   - LocalVariableSuffix of ``_post``
+
+Identifies and/or transforms local variable names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void foo() { int local_Constant; }
+
+After:
+
+.. code-block:: c++
+
+    void foo() { int pre_local_constant_post; }
+
+.. option:: MemberCase
+
+    When defined, the checker will check member names conform to the
+    selected casing.
+
+.. option:: MemberPrefix
+
+    When defined, the checker will check member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: MemberSuffix
+
+    When defined, the checker will check member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - MemberCase of ``lower_case``
+   - MemberPrefix of ``pre_``
+   - MemberSuffix of ``_post``
+
+Identifies and/or transforms member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+      char MY_ConstMember_string[4];
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+      char pre_my_constmember_string_post[4];
+    }
+
+.. option:: MethodCase
+
+    When defined, the checker will check method names conform to the
+    selected casing.
+
+.. option:: MethodPrefix
+
+    When defined, the checker will check method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: MethodSuffix
+
+    When defined, the checker will check method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - MethodCase of ``lower_case``
+   - MethodPrefix of ``pre_``
+   - MethodSuffix of ``_post``
+
+Identifies and/or transforms method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+      char MY_Method_string();
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+      char pre_my_method_string_post();
+    }
+
+.. option:: NamespaceCase
+
+    When defined, the checker will check namespace names conform to the
+    selected casing.
+
+.. option:: NamespacePrefix
+
+    When defined, the checker will check namespace names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: NamespaceSuffix
+
+    When defined, the checker will check namespace names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - NamespaceCase of ``lower_case``
+   - NamespacePrefix of ``pre_``
+   - NamespaceSuffix of ``_post``
+
+Identifies and/or transforms namespace names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    namespace FOO_NS {
+    ...
+    }
+
+After:
+
+.. code-block:: c++
+
+    namespace pre_foo_ns_post {
+    ...
+    }
+
+.. option:: ParameterCase
+
+    When defined, the checker will check parameter names conform to the
+    selected casing.
+
+.. option:: ParameterPrefix
+
+    When defined, the checker will check parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ParameterSuffix
+
+    When defined, the checker will check parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ParameterCase of ``lower_case``
+   - ParameterPrefix of ``pre_``
+   - ParameterSuffix of ``_post``
+
+Identifies and/or transforms parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int PARAMETER_1, int const CONST_parameter);
+
+After:
+
+.. code-block:: c++
+
+    void GLOBAL_FUNCTION(int pre_parameter_post, int const CONST_parameter);
+
+.. option:: ParameterPackCase
+
+    When defined, the checker will check parameter pack names conform to the
+    selected casing.
+
+.. option:: ParameterPackPrefix
+
+    When defined, the checker will check parameter pack names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ParameterPackSuffix
+
+    When defined, the checker will check parameter pack names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ParameterPackCase of ``lower_case``
+   - ParameterPackPrefix of ``pre_``
+   - ParameterPackSuffix of ``_post``
+
+Identifies and/or transforms parameter pack names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    template <typename... TYPE_parameters> {
+      void FUNCTION(int... TYPE_parameters);
+    }
+
+After:
+
+.. code-block:: c++
+
+    template <typename... TYPE_parameters> {
+      void FUNCTION(int... pre_type_parameters_post);
+    }
+
+.. option:: PointerParameterCase
+
+    When defined, the checker will check pointer parameter names conform to the
+    selected casing.
+
+.. option:: PointerParameterPrefix
+
+    When defined, the checker will check pointer parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: PointerParameterSuffix
+
+    When defined, the checker will check pointer parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - PointerParameterCase of ``lower_case``
+   - PointerParameterPrefix of ``pre_``
+   - PointerParameterSuffix of ``_post``
+
+Identifies and/or transforms pointer parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    void FUNCTION(int *PARAMETER);
+
+After:
+
+.. code-block:: c++
+
+    void FUNCTION(int *pre_parameter_post);
+
+.. option:: PrivateMemberCase
+
+    When defined, the checker will check private member names conform to the
+    selected casing.
+
+.. option:: PrivateMemberPrefix
+
+    When defined, the checker will check private member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: PrivateMemberSuffix
+
+    When defined, the checker will check private member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - PrivateMemberCase of ``lower_case``
+   - PrivateMemberPrefix of ``pre_``
+   - PrivateMemberSuffix of ``_post``
+
+Identifies and/or transforms private member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    private:
+      int Member_Variable;
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    private:
+      int pre_member_variable_post;
+    }
+
+.. option:: PrivateMethodCase
+
+    When defined, the checker will check private method names conform to the
+    selected casing.
+
+.. option:: PrivateMethodPrefix
+
+    When defined, the checker will check private method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: PrivateMethodSuffix
+
+    When defined, the checker will check private method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - PrivateMethodCase of ``lower_case``
+   - PrivateMethodPrefix of ``pre_``
+   - PrivateMethodSuffix of ``_post``
+
+Identifies and/or transforms private method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    private:
+      int Member_Method();
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    private:
+      int pre_member_method_post();
+    }
+
+.. option:: ProtectedMemberCase
+
+    When defined, the checker will check protected member names conform to the
+    selected casing.
+
+.. option:: ProtectedMemberPrefix
+
+    When defined, the checker will check protected member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ProtectedMemberSuffix
+
+    When defined, the checker will check protected member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ProtectedMemberCase of ``lower_case``
+   - ProtectedMemberPrefix of ``pre_``
+   - ProtectedMemberSuffix of ``_post``
+
+Identifies and/or transforms protected member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    protected:
+      int Member_Variable;
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    protected:
+      int pre_member_variable_post;
+    }
+
+.. option:: ProtectedMethodCase
+
+    When defined, the checker will check protect method names conform to the
+    selected casing.
+
+.. option:: ProtectedMethodPrefix
+
+    When defined, the checker will check protect method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ProtectedMethodSuffix
+
+    When defined, the checker will check protect method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ProtectedMethodCase of ``lower_case``
+   - ProtectedMethodPrefix of ``pre_``
+   - ProtectedMethodSuffix of ``_post``
+
+Identifies and/or transforms protect method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    protected:
+      int Member_Method();
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    protected:
+      int pre_member_method_post();
+    }
+
+.. option:: PublicMemberCase
+
+    When defined, the checker will check public member names conform to the
+    selected casing.
+
+.. option:: PublicMemberPrefix
+
+    When defined, the checker will check public member names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: PublicMemberSuffix
+
+    When defined, the checker will check public member names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - PublicMemberCase of ``lower_case``
+   - PublicMemberPrefix of ``pre_``
+   - PublicMemberSuffix of ``_post``
+
+Identifies and/or transforms public member names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      int Member_Variable;
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      int pre_member_variable_post;
+    }
+
+.. option:: PublicMethodCase
+
+    When defined, the checker will check public method names conform to the
+    selected casing.
+
+.. option:: PublicMethodPrefix
+
+    When defined, the checker will check public method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: PublicMethodSuffix
+
+    When defined, the checker will check public method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - PublicMethodCase of ``lower_case``
+   - PublicMethodPrefix of ``pre_``
+   - PublicMethodSuffix of ``_post``
+
+Identifies and/or transforms public method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      int Member_Method();
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      int pre_member_method_post();
+    }
+
+.. option:: StaticConstantCase
+
+    When defined, the checker will check static constant names conform to the
+    selected casing.
+
+.. option:: StaticConstantPrefix
+
+    When defined, the checker will check static constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: StaticConstantSuffix
+
+    When defined, the checker will check static constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - StaticConstantCase of ``lower_case``
+   - StaticConstantPrefix of ``pre_``
+   - StaticConstantSuffix of ``_post``
+
+Identifies and/or transforms static constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    static unsigned const MyConstStatic_array[] = {1, 2, 3};
+
+After:
+
+.. code-block:: c++
+
+    static unsigned const pre_myconststatic_array_post[] = {1, 2, 3};
+
+.. option:: StaticVariableCase
+
+    When defined, the checker will check static variable names conform to the
+    selected casing.
+
+.. option:: StaticVariablePrefix
+
+    When defined, the checker will check static variable names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: StaticVariableSuffix
+
+    When defined, the checker will check static variable names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - StaticVariableCase of ``lower_case``
+   - StaticVariablePrefix of ``pre_``
+   - StaticVariableSuffix of ``_post``
+
+Identifies and/or transforms static variable names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    static unsigned MyStatic_array[] = {1, 2, 3};
+
+After:
+
+.. code-block:: c++
+
+    static unsigned pre_mystatic_array_post[] = {1, 2, 3};
+
+.. option:: StructCase
+
+    When defined, the checker will check struct names conform to the
+    selected casing.
+
+.. option:: StructPrefix
+
+    When defined, the checker will check struct names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: StructSuffix
+
+    When defined, the checker will check struct names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - StructCase of ``lower_case``
+   - StructPrefix of ``pre_``
+   - StructSuffix of ``_post``
+
+Identifies and/or transforms struct names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    struct FOO {
+      FOO();
+      ~FOO();
+    };
+
+After:
+
+.. code-block:: c++
+
+    struct pre_foo_post {
+      pre_foo_post();
+      ~pre_foo_post();
+    };
+
+.. option:: TemplateParameterCase
+
+    When defined, the checker will check template parameter names conform to the
+    selected casing.
+
+.. option:: TemplateParameterPrefix
+
+    When defined, the checker will check template parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: TemplateParameterSuffix
+
+    When defined, the checker will check template parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - TemplateParameterCase of ``lower_case``
+   - TemplateParameterPrefix of ``pre_``
+   - TemplateParameterSuffix of ``_post``
+
+Identifies and/or transforms template parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    template <typename T> class Foo {};
+
+After:
+
+.. code-block:: c++
+
+    template <typename pre_t_post> class Foo {};
+
+.. option:: TemplateTemplateParameterCase
+
+    When defined, the checker will check template template parameter names conform to the
+    selected casing.
+
+.. option:: TemplateTemplateParameterPrefix
+
+    When defined, the checker will check template template parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: TemplateTemplateParameterSuffix
+
+    When defined, the checker will check template template parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - TemplateTemplateParameterCase of ``lower_case``
+   - TemplateTemplateParameterPrefix of ``pre_``
+   - TemplateTemplateParameterSuffix of ``_post``
+
+Identifies and/or transforms template template parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    template <template <typename> class TPL_parameter, int COUNT_params,
+              typename... TYPE_parameters>
+
+After:
+
+.. code-block:: c++
+
+    template <template <typename> class pre_tpl_parameter_post, int COUNT_params,
+              typename... TYPE_parameters>
+
+.. option:: TypeAliasCase
+
+    When defined, the checker will check type alias names conform to the
+    selected casing.
+
+.. option:: TypeAliasPrefix
+
+    When defined, the checker will check type alias names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: TypeAliasSuffix
+
+    When defined, the checker will check type alias names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - TypeAliasCase of ``lower_case``
+   - TypeAliasPrefix of ``pre_``
+   - TypeAliasSuffix of ``_post``
+
+Identifies and/or transforms type alias names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    using MY_STRUCT_TYPE = my_structure;
+
+After:
+
+.. code-block:: c++
+
+    using pre_my_struct_type_post = my_structure;
+
+.. option:: TypedefCase
+
+    When defined, the checker will check typedef names conform to the
+    selected casing.
+
+.. option:: TypedefPrefix
+
+    When defined, the checker will check typedef names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: TypedefSuffix
+
+    When defined, the checker will check typedef names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - TypedefCase of ``lower_case``
+   - TypedefPrefix of ``pre_``
+   - TypedefSuffix of ``_post``
+
+Identifies and/or transforms typedef names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    typedef int MYINT;
+
+After:
+
+.. code-block:: c++
+
+    typedef int pre_myint_post;
+
+.. option:: TypeTemplateParameterCase
+
+    When defined, the checker will check type template parameter names conform to the
+    selected casing.
+
+.. option:: TypeTemplateParameterPrefix
+
+    When defined, the checker will check type template parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: TypeTemplateParameterSuffix
+
+    When defined, the checker will check type template parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - TypeTemplateParameterCase of ``lower_case``
+   - TypeTemplateParameterPrefix of ``pre_``
+   - TypeTemplateParameterSuffix of ``_post``
+
+Identifies and/or transforms type template parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    template <template <typename> class TPL_parameter, int COUNT_params,
+              typename... TYPE_parameters>
+
+After:
+
+.. code-block:: c++
+
+    template <template <typename> class TPL_parameter, int COUNT_params,
+              typename... pre_type_parameters_post>
+
+.. option:: UnionCase
+
+    When defined, the checker will check union names conform to the
+    selected casing.
+
+.. option:: UnionPrefix
+
+    When defined, the checker will check union names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: UnionSuffix
+
+    When defined, the checker will check union names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - UnionCase of ``lower_case``
+   - UnionPrefix of ``pre_``
+   - UnionSuffix of ``_post``
+
+Identifies and/or transforms union names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    union FOO {
+      int a;
+      char b;
+    };
+
+After:
+
+.. code-block:: c++
+
+    union pre_foo_post {
+      int a;
+      char b;
+    };
+
+.. option:: ValueTemplateParameterCase
+
+    When defined, the checker will check value template parameter names conform to the
+    selected casing.
+
+.. option:: ValueTemplateParameterPrefix
+
+    When defined, the checker will check value template parameter names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ValueTemplateParameterSuffix
+
+    When defined, the checker will check value template parameter names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ValueTemplateParameterCase of ``lower_case``
+   - ValueTemplateParameterPrefix of ``pre_``
+   - ValueTemplateParameterSuffix of ``_post``
+
+Identifies and/or transforms value template parameter names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    template <template <typename> class TPL_parameter, int COUNT_params,
+              typename... TYPE_parameters>
+
+After:
+
+.. code-block:: c++
+
+    template <template <typename> class TPL_parameter, int pre_count_params_post,
+              typename... TYPE_parameters>
+
+.. option:: VariableCase
+
+    When defined, the checker will check variable names conform to the
+    selected casing.
+
+.. option:: VariablePrefix
+
+    When defined, the checker will check variable names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: VariableSuffix
+
+    When defined, the checker will check variable names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - VariableCase of ``lower_case``
+   - VariablePrefix of ``pre_``
+   - VariableSuffix of ``_post``
+
+Identifies and/or transforms variable names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    unsigned MyVariable;
+
+After:
+
+.. code-block:: c++
+
+    unsigned pre_myvariable_post;
+
+.. option:: VirtualMethodCase
+
+    When defined, the checker will check virtual method names conform to the
+    selected casing.
+
+.. option:: VirtualMethodPrefix
+
+    When defined, the checker will check virtual method names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: VirtualMethodSuffix
+
+    When defined, the checker will check virtual method names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - VirtualMethodCase of ``lower_case``
+   - VirtualMethodPrefix of ``pre_``
+   - VirtualMethodSuffix of ``_post``
+
+Identifies and/or transforms virtual method names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      virtual int MemberFunction();
+    }
+
+After:
+
+.. code-block:: c++
+
+    class Foo {
+    public:
+      virtual int pre_member_function_post();
+    }