diff --git a/recipes/boost/all/conanfile.py b/recipes/boost/all/conanfile.py
index 1982c151552a3..b12a2e7a11e71 100644
--- a/recipes/boost/all/conanfile.py
+++ b/recipes/boost/all/conanfile.py
@@ -1,7 +1,7 @@
 from conan import ConanFile
 from conan.errors import ConanException, ConanInvalidConfiguration
 from conan.tools.apple import is_apple_os, to_apple_arch, XCRun
-from conan.tools.build import build_jobs, cross_building, valid_min_cppstd, supported_cppstd
+from conan.tools.build import build_jobs, cross_building, can_run, valid_min_cppstd, cppstd_flag
 from conan.tools.env import VirtualBuildEnv
 from conan.tools.files import (
     apply_conandata_patches, chdir, collect_libs, copy, export_conandata_patches,
@@ -21,7 +21,7 @@
 import sys
 import yaml
 
-required_conan_version = ">=1.53.0"
+required_conan_version = ">=2.2.0"
 
 # When adding (or removing) an option, also add this option to the list in
 # `rebuild-dependencies.yml` and re-run that script.
@@ -162,66 +162,6 @@ def export(self):
     def export_sources(self):
         export_conandata_patches(self)
 
-    def _cppstd_flag(self, compiler_cppstd=None):
-        """Return the flag for the given C++ standard and compiler"""
-        # TODO: Replace it by Conan tool when available: https://github.com/conan-io/conan/issues/12603
-        compiler = self.settings.get_safe("compiler")
-        compiler_version = self.settings.get_safe("compiler.version")
-        cppstd = self.settings.get_safe("compiler.cppstd") or compiler_cppstd
-        if not compiler or not compiler_version or not cppstd:
-            return ""
-
-        def _cppstd_gcc(gcc_version, cppstd):
-            """Return the flag for the given C++ standard and GCC version"""
-            cppstd_flags = {}
-            cppstd_flags.setdefault("98", "98" if gcc_version >= "3.4" else None)
-            cppstd_flags.setdefault("11", "11" if gcc_version >= "4.7" else "0x" if gcc_version >= "4.3" else None)
-            cppstd_flags.setdefault("14", "14" if gcc_version >= "4.9" else "1y" if gcc_version >= "4.8" else None)
-            cppstd_flags.setdefault("17", "17" if gcc_version >= "5.2" else "1z" if gcc_version >= "5" else None)
-            cppstd_flags.setdefault("20", "2a" if gcc_version >= "8" else "20" if gcc_version >= "12" else None)
-            cppstd_flags.setdefault("23", "2b" if gcc_version >= "11" else None)
-            return cppstd_flags.get(cppstd.lstrip("gnu"))
-
-        def _cppstd_clang(clang_version, cppstd):
-            """Return the flag for the given C++ standard and Clang version"""
-            cppstd_flags = {}
-            cppstd_flags.setdefault("98", "98" if clang_version >= "2.1" else None)
-            cppstd_flags.setdefault("11", "11" if clang_version >= "3.1" else "0x" if clang_version >= "2.1" else None)
-            cppstd_flags.setdefault("14", "14" if clang_version >= "3.5" else "1y" if clang_version >= "3.4" else None)
-            cppstd_flags.setdefault("17", "17" if clang_version >= "5" else "1z" if clang_version >= "3.5" else None)
-            cppstd_flags.setdefault("20", "2a" if clang_version >= "6" else "20" if clang_version >= "12" else None)
-            cppstd_flags.setdefault("23", "2b" if clang_version >= "13"  else "23" if clang_version >= "17" else None)
-            return cppstd_flags.get(cppstd.lstrip("gnu"))
-
-
-        def _cppstd_apple_clang(clang_version, cppstd):
-            """Return the flag for the given C++ standard and Apple Clang version"""
-            cppstd_flags = {}
-            cppstd_flags.setdefault("98", "98" if clang_version >= "4.0" else None)
-            cppstd_flags.setdefault("11", "11" if clang_version >= "4.0" else None)
-            cppstd_flags.setdefault("14", "14" if clang_version >= "6.1" else "1y" if clang_version >= "5.1" else None)
-            cppstd_flags.setdefault("17", "17" if clang_version >= "9.1" else "1z" if clang_version >= "6.1" else None)
-            cppstd_flags.setdefault("20", "20" if clang_version >= "13.0" else "2a" if clang_version >= "10.0" else None)
-            cppstd_flags.setdefault("23", "2b" if clang_version >= "13.0" else None)
-            return cppstd_flags.get(cppstd.lstrip("gnu"))
-
-        def _cppstd_msvc(visual_version, cppstd):
-            """Return the flag for the given C++ standard and MSVC version"""
-            cppstd_flags = {}
-            cppstd_flags.setdefault("98", "98")
-            cppstd_flags.setdefault("11", "11")
-            cppstd_flags.setdefault("14", "14" if visual_version >= "190" else None)
-            cppstd_flags.setdefault("17", "17" if visual_version >= "191" else "latest" if visual_version >= "190" else None)
-            cppstd_flags.setdefault("20", "20" if visual_version >= "192" else "latest" if visual_version >= "191" else None)
-            cppstd_flags.setdefault("23", "latest" if visual_version >= "193" else None)
-            return cppstd_flags.get(cppstd)
-
-        func = {"gcc": _cppstd_gcc, "clang": _cppstd_clang, "apple-clang": _cppstd_apple_clang, "msvc": _cppstd_msvc}.get(compiler)
-        flag = cppstd
-        if func:
-            flag = func(Version(compiler_version), str(cppstd))
-        return flag
-
     @property
     def _min_compiler_version_default_cxx11(self):
         """ Minimum compiler version having c++ standard >= 11
@@ -230,7 +170,6 @@ def _min_compiler_version_default_cxx11(self):
             "gcc": 6,
             "clang": 6,
             "apple-clang": 99,  # still uses C++98 by default. XCode does not reflect apple-clang
-            "Visual Studio": 14,  # guess
             "msvc": 190,  # guess
         }.get(str(self.settings.compiler))
 
@@ -245,7 +184,6 @@ def _min_compiler_version_default_cxx14(self):
             "gcc": 6,
             "clang": 6,
             "apple-clang": 99,  # still uses C++98 by default. XCode does not reflect apple-clang
-            "Visual Studio": 15,  # guess
             "msvc": 191,  # guess
         }.get(str(self.settings.compiler))
 
@@ -255,64 +193,21 @@ def _min_compiler_version_default_cxx20(self):
             "gcc": 99,
             "clang": 99,
             "apple-clang": 99,
-            "Visual Studio": 99,
             "msvc": 999,
         }.get(str(self.settings.compiler))
 
-    @property
-    def _has_cppstd_11_supported(self):
-        cppstd = self.settings.compiler.get_safe("cppstd")
-        if cppstd:
-            return valid_min_cppstd(self, 11)
-        compiler_version = self._min_compiler_version_default_cxx11
-        if compiler_version:
-            return (Version(self.settings.compiler.version) >= compiler_version) or "11" in supported_cppstd(self)
-
-    @property
-    def _has_cppstd_14_supported(self):
-        cppstd = self.settings.compiler.get_safe("cppstd")
-        if cppstd:
-            return valid_min_cppstd(self, 14)
-        required_compiler_version = self._min_compiler_version_default_cxx14
-        if required_compiler_version:
-            msvc_versions = {14: 190, 15: 191, 16: 192, 17: 193}
-            compiler_version = Version(self.settings.compiler.version)
-            is_visual_studio = str(self.settings.compiler) == "Visual Studio"
-            # supported_cppstd only supports msvc, but not Visual Studio as compiler
-            supported_cxx14 = "14" in supported_cppstd(self, "msvc", msvc_versions.get(compiler_version)) if is_visual_studio else "14" in supported_cppstd(self)
-            # supported_cppstd: lists GCC 5 due partial support for C++14, but not enough for Boost
-            return (compiler_version >= required_compiler_version) and supported_cxx14
-
-    @property
-    def _has_cppstd_20_supported(self):
-        cppstd = self.settings.compiler.get_safe("cppstd")
-        if cppstd:
-            return valid_min_cppstd(self, 20)
-        required_compiler_version = self._min_compiler_version_default_cxx20
-        if required_compiler_version:
-            msvc_versions = {14: 190, 15: 191, 16: 192, 17: 193}
-            compiler_version = Version(self.settings.compiler.version)
-            is_visual_studio = str(self.settings.compiler) == "Visual Studio"
-            # supported_cppstd only supports msvc, but not Visual Studio as compiler
-            supported_cxx20 = "20" in supported_cppstd(self, "msvc", msvc_versions.get(compiler_version)) if is_visual_studio else "20" in supported_cppstd(self)
-            # We still dont have a compiler using C++20 by default
-            return (compiler_version >= required_compiler_version) or supported_cxx20
-
     @property
     def _has_coroutine_supported(self):
-        cppstd = self.settings.compiler.get_safe("cppstd")
-        cppstd_20_supported = True
-        if cppstd:
-            cppstd_20_supported = valid_min_cppstd(self, 20)
+        cppstd_20_supported = valid_min_cppstd(self, 20)
         # https://en.cppreference.com/w/cpp/compiler_support#cpp20
         # https://releases.llvm.org/14.0.0/tools/clang/docs/ReleaseNotes.html#clang-format: before is experimental header
         # https://gcc.gnu.org/gcc-10/changes.html: requires -fcoroutines
         min_compiler_versions = {
-                "apple-clang": "12",
-                "clang": "14",
-                "gcc": "10",
-                "msvc": "192",
-                "Visual Studio": "16",}
+            "apple-clang": "12",
+            "clang": "14",
+            "gcc": "10",
+            "msvc": "192",
+        }
         required_compiler_version = min_compiler_versions.get(str(self.settings.compiler))
         if not required_compiler_version:
             return cppstd_20_supported
@@ -324,7 +219,6 @@ def _min_compiler_version_nowide(self):
         return {
             "gcc": 4.8,
             "clang": 5,
-            "Visual Studio": 14,  # guess
             "msvc": 190,  # guess
         }.get(str(self.settings.compiler))
 
@@ -372,10 +266,6 @@ def _all_super_modules(self, name):
     def _bcp_dir(self):
         return "custom-boost"
 
-    @property
-    def _settings_build(self):
-        return getattr(self, "settings_build", self.settings)
-
     @property
     def _is_clang_cl(self):
         return self.settings.os == "Windows" and self.settings.compiler == "clang"
@@ -410,32 +300,6 @@ def config_options(self):
         if self.settings.os == "Windows":
             del self.options.with_stacktrace_backtrace
 
-        # nowide requires a c++11-able compiler + movable std::fstream: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
-        # json requires a c++11-able compiler: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
-        if self.settings.compiler.get_safe("cppstd"):
-            if not valid_min_cppstd(self, 11):
-                self.options.without_fiber = True
-                self.options.without_nowide = True
-                self.options.without_json = True
-                self.options.without_url = True
-        else:
-            version_cxx11_standard_json = self._min_compiler_version_default_cxx11
-            if version_cxx11_standard_json:
-                if not self._has_cppstd_11_supported:
-                    self.options.without_fiber = True
-                    self.options.without_json = True
-                    self.options.without_nowide = True
-                    self.options.without_url = True
-            else:
-                self.options.without_fiber = True
-                self.options.without_json = True
-                self.options.without_nowide = True
-                self.options.without_url = True
-        if Version(self.version) >= "1.85.0" and not self._has_cppstd_14_supported:
-            self.options.without_math = True
-        if Version(self.version) >= "1.86.0" and not self._has_cppstd_14_supported:
-            self.options.without_graph = True
-
         # iconv is off by default on Windows and Solaris
         if self._is_windows_platform or self.settings.os == "SunOS":
             self.options.i18n_backend_iconv = "off"
@@ -452,148 +316,51 @@ def config_options(self):
             if dep_name not in self._configure_options:
                 delattr(self.options, f"without_{dep_name}")
 
-        def disable_math():
-            super_modules = self._all_super_modules("math")
-            for smod in super_modules:
-                try:
-                    setattr(self.options, f"without_{smod}", True)
-                except ConanException:
-                    pass
-
-        def disable_graph():
-            super_modules = self._all_super_modules("graph")
+        def disable_component(name):
+            super_modules = self._all_super_modules(name)
             for smod in super_modules:
                 try:
                     setattr(self.options, f"without_{smod}", True)
                 except ConanException:
                     pass
 
-        # Starting from 1.76.0, Boost.Math requires a c++11 capable compiler
-        # ==> disable it by default for older compilers or c++ standards
-        if self.settings.compiler.get_safe("cppstd"):
-            if not valid_min_cppstd(self, 11):
-                disable_math()
-        else:
-            min_compiler_version = self._min_compiler_version_default_cxx11
-            if min_compiler_version is None:
-                self.output.warning("Assuming the compiler supports c++11 by default")
-            elif not self._has_cppstd_11_supported:
-                disable_math()
-            # Boost.Math is not built when the compiler is GCC < 5 and uses C++11
-            elif self.settings.compiler == "gcc" and Version(self.settings.compiler.version) < "5":
-                disable_math()
+        # nowide requires a c++11-able compiler + movable std::fstream: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
+        # json requires a c++11-able compiler: change default to not build on compiler with too old default c++ standard or too low compiler.cppstd
+        if not valid_min_cppstd(self, 11):
+            disable_component("fiber")
+            disable_component("nowide")
+            disable_component("json")
+            disable_component("url")
+            disable_component("math")
 
         if Version(self.version) >= "1.79.0":
-            # Starting from 1.79.0, Boost.Wave requires a c++11 capable compiler
-            # ==> disable it by default for older compilers or c++ standards
-
-            def disable_wave():
-                super_modules = self._all_super_modules("wave")
-                for smod in super_modules:
-                    try:
-                        setattr(self.options, f"without_{smod}", True)
-                    except ConanException:
-                        pass
-
-            if self.settings.compiler.get_safe("cppstd"):
-                if not valid_min_cppstd(self, 11):
-                    disable_wave()
-            else:
-                min_compiler_version = self._min_compiler_version_default_cxx11
-                if min_compiler_version is None:
-                    self.output.warning("Assuming the compiler supports c++11 by default")
-                elif not self._has_cppstd_11_supported:
-                    disable_wave()
-                # Boost.Wave is not built when the compiler is GCC < 5 and uses C++11
-                elif self.settings.compiler == "gcc" and Version(self.settings.compiler.version) < "5":
-                    disable_wave()
+            if not valid_min_cppstd(self, 11):
+                disable_component("wave")
 
         if Version(self.version) >= "1.81.0":
-            # Starting from 1.81.0, Boost.Locale requires a c++11 capable compiler
-            # ==> disable it by default for older compilers or c++ standards
-
-            def disable_locale():
-                super_modules = self._all_super_modules("locale")
-                for smod in super_modules:
-                    try:
-                        setattr(self.options, f"without_{smod}", True)
-                    except ConanException:
-                        pass
-
-            if self.settings.compiler.get_safe("cppstd"):
-                if not valid_min_cppstd(self, 11):
-                    disable_locale()
-            else:
-                min_compiler_version = self._min_compiler_version_default_cxx11
-                if min_compiler_version is None:
-                    self.output.warning("Assuming the compiler supports c++11 by default")
-                elif not self._has_cppstd_11_supported:
-                    disable_locale()
-                # Boost.Locale is not built when the compiler is GCC < 5 and uses C++11
-                elif self.settings.compiler == "gcc" and Version(self.settings.compiler.version) < "5":
-                    disable_locale()
+            if not valid_min_cppstd(self, 11):
+                disable_component("locale")
 
         if Version(self.version) >= "1.84.0":
-            # Starting from 1.84.0, Boost.Cobalt requires a c++20 capable compiler
-            # ==> disable it by default for older compilers or c++ standards
-
-            def disable_cobalt():
-                super_modules = self._all_super_modules("cobalt")
-                for smod in super_modules:
-                    try:
-                        setattr(self.options, f"without_{smod}", True)
-                    except ConanException:
-                        pass
-
             if not self._has_coroutine_supported:
-                disable_cobalt()
-            elif self.settings.compiler.get_safe("cppstd"):
-                if not valid_min_cppstd(self, 20):
-                    disable_cobalt()
-            else:
-                min_compiler_version = self._min_compiler_version_default_cxx20
-                if min_compiler_version is None:
-                    self.output.warning("Assuming the compiler supports c++20 by default")
-                elif Version(self.settings.compiler.version) < min_compiler_version:
-                    disable_cobalt()
-
+                disable_component("cobalt")
             # FIXME: Compilation errors on msvc shared build for boost.fiber https://github.com/boostorg/fiber/issues/314
             if is_msvc(self):
-                self.options.without_fiber = True
+                disable_component("fiber")
 
         if Version(self.version) >= "1.85.0":
-            # Starting from 1.85.0, Boost.Math requires a c++14 capable compiler
-            # https://github.com/boostorg/math/blob/boost-1.85.0/README.md
-            # ==> disable it by default for older compilers or c++ standards
-            if self.settings.compiler.get_safe("cppstd"):
-                if not valid_min_cppstd(self, 14):
-                    disable_math()
-            else:
-                min_compiler_version = self._min_compiler_version_default_cxx14
-                if min_compiler_version is None:
-                    self.output.warning("Assuming the compiler supports c++14 by default")
-                elif not self._has_cppstd_14_supported:
-                    disable_math()
+            if not valid_min_cppstd(self, 14):
+                disable_component("math")
 
         if Version(self.version) >= "1.86.0":
-            # Boost 1.86.0 updated more components that require C++14 and C++17
-            # https://www.boost.org/users/history/version_1_86_0.html
-            if self.settings.compiler.get_safe("cppstd"):
-                if not valid_min_cppstd(self, 14):
-                    disable_graph()
-            else:
-                min_compiler_version = self._min_compiler_version_default_cxx14
-                if min_compiler_version is None:
-                    self.output.warning("Assuming the compiler supports c++14 by default")
-                elif not self._has_cppstd_14_supported:
-                    disable_graph()
-
+            if not valid_min_cppstd(self, 14):
+                disable_component("graph")
             # TODO: Revisit on Boost 1.87.0
             # It's not possible to disable process only when having shared parsed already.
             # https://github.com/boostorg/process/issues/408
             # https://github.com/boostorg/process/pull/409
             if Version(self.version) == "1.86.0" and is_msvc(self):
-                setattr(self.options, "without_process", True)
+                disable_component("process")
 
     @property
     def _configure_options(self):
@@ -748,13 +515,12 @@ def validate(self):
             if mincompiler_version and Version(self.settings.compiler.version) < mincompiler_version:
                 raise ConanInvalidConfiguration("This compiler is too old to build Boost.nowide.")
 
-        for cxx_standard, boost_libraries, has_cppstd_supported in [
-             (11, self._cxx11_boost_libraries, self._has_cppstd_11_supported),
-             (14, self._cxx14_boost_libraries, self._has_cppstd_14_supported),
-             (20, self._cxx20_boost_libraries, self._has_cppstd_20_supported)]:
-            if any([not self.options.get_safe(f"without_{library}", True) for library in boost_libraries]):
-                if (self.settings.compiler.get_safe("cppstd") and not valid_min_cppstd(self, cxx_standard)) or \
-                    not has_cppstd_supported:
+        for cxx_standard, boost_libraries in [
+             (11, self._cxx11_boost_libraries),
+             (14, self._cxx14_boost_libraries),
+             (20, self._cxx20_boost_libraries)]:
+            if any(not self.options.get_safe(f"without_{library}", True) for library in boost_libraries):
+                if not valid_min_cppstd(self, cxx_standard):
                     raise ConanInvalidConfiguration(
                         f"Boost libraries {', '.join(boost_libraries)} requires a C++{cxx_standard} compiler. "
                         "Please, set compiler.cppstd or use a newer compiler version or disable from building."
@@ -840,8 +606,7 @@ def build_requirements(self):
             self.tool_requires("b2/[>=5.2 <6]")
 
     def source(self):
-        get(self, **self.conan_data["sources"][self.version],
-            destination=self.source_folder, strip_root=True)
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
         apply_conandata_patches(self)
 
     def generate(self):
@@ -918,7 +683,7 @@ def _get_python_var(self, name):
         python_version_parts = str(self.info.options.python_version).split('.')
         python_major = int(python_version_parts[0])
         python_minor = int(python_version_parts[1])
-        if(python_major >= 3 and python_minor >= 10):
+        if python_major >= 3 and python_minor >= 10:
             return self._get_python_sc_var(name)
 
         return self._get_python_sc_var(name) or self._get_python_du_var(name)
@@ -1093,10 +858,10 @@ def _run_bcp(self):
 
     def build(self):
         stacktrace_jamfile = os.path.join(self.source_folder, "libs", "stacktrace", "build", "Jamfile.v2")
-        if cross_building(self, skip_x64_x86=True):
+        if not can_run(self):
             # When cross building, do not attempt to run the test-executable (assume they work)
             replace_in_file(self, stacktrace_jamfile, "$(>) > $(<)", "echo \"\" > $(<)", strict=False)
-        if self._with_stacktrace_backtrace and self.settings.os != "Windows" and not cross_building(self):
+        if self._with_stacktrace_backtrace and self.settings.os != "Windows" and can_run(self):
             # When libbacktrace is shared, give extra help to the test-executable
             linker_var = "DYLD_LIBRARY_PATH" if self.settings.os == "Macos" else "LD_LIBRARY_PATH"
             libbacktrace_libdir = self.dependencies["libbacktrace"].cpp_info.aggregated_components().libdirs[0]
@@ -1326,18 +1091,10 @@ def add_defines(library):
 
         flags.append(f"toolset={self._toolset}")
 
-        safe_cppstd = self.settings.get_safe("compiler.cppstd")
-        if safe_cppstd:
-            cppstd_version = self._cppstd_flag(safe_cppstd)
-            flags.append(f"cxxstd={cppstd_version}")
-            if "gnu" in safe_cppstd:
-                flags.append("cxxstd-dialect=gnu")
-        elif Version(self.version) >= "1.85.0" and self._has_cppstd_14_supported:
-            cppstd_version = self._cppstd_flag("14")
-            flags.append(f"cxxstd={cppstd_version}")
-        elif self._has_cppstd_11_supported:
-            cppstd_version = self._cppstd_flag("11")
-            flags.append(f"cxxstd={cppstd_version}")
+        cppstd_flag_year = cppstd_flag(self)[-2:]
+        flags.append(f"cxxstd={cppstd_flag_year}")
+        if "gnu" in self.settings.compiler.cppstd:
+            flags.append("cxxstd-dialect=gnu")
 
         # LDFLAGS
         link_flags = []
@@ -1654,7 +1411,6 @@ def _toolset_tag(self):
         # Visual Studio  | 17               | Windows     | vc142          | depends on compiler.toolset
         compiler = {
             "apple-clang": "",
-            "Visual Studio": "vc",
             "msvc": "vc",
         }.get(str(self.settings.compiler), str(self.settings.compiler))
         if (self.settings.compiler, self.settings.os) == ("gcc", "Windows"):
@@ -1734,10 +1490,6 @@ def package_info(self):
         self.env_info.BOOST_ROOT = self.package_folder
 
         self.cpp_info.set_property("cmake_file_name", "Boost")
-        self.cpp_info.filenames["cmake_find_package"] = "Boost"
-        self.cpp_info.filenames["cmake_find_package_multi"] = "Boost"
-        self.cpp_info.names["cmake_find_package"] = "Boost"
-        self.cpp_info.names["cmake_find_package_multi"] = "Boost"
 
         # - Use 'headers' component for all includes + defines
         # - Use '_libboost' component to attach extra system_libs, ...
@@ -1745,9 +1497,6 @@ def package_info(self):
         self.cpp_info.components["headers"].libs = []
         self.cpp_info.components["headers"].libdirs = []
         self.cpp_info.components["headers"].set_property("cmake_target_name", "Boost::headers")
-        self.cpp_info.components["headers"].names["cmake_find_package"] = "headers"
-        self.cpp_info.components["headers"].names["cmake_find_package_multi"] = "headers"
-        self.cpp_info.components["headers"].names["pkg_config"] = "boost"
 
         if self.options.system_no_deprecated:
             self.cpp_info.components["headers"].defines.append("BOOST_SYSTEM_NO_DEPRECATED")
@@ -1788,8 +1537,6 @@ def package_info(self):
         # Boost::boost is an alias of Boost::headers
         self.cpp_info.components["_boost_cmake"].requires = ["headers"]
         self.cpp_info.components["_boost_cmake"].set_property("cmake_target_name", "Boost::boost")
-        self.cpp_info.components["_boost_cmake"].names["cmake_find_package"] = "boost"
-        self.cpp_info.components["_boost_cmake"].names["cmake_find_package_multi"] = "boost"
         if self.options.header_only:
             self.cpp_info.components["_boost_cmake"].libdirs = []
 
@@ -1798,9 +1545,6 @@ def package_info(self):
 
             self.cpp_info.components["diagnostic_definitions"].libs = []
             self.cpp_info.components["diagnostic_definitions"].set_property("cmake_target_name", "Boost::diagnostic_definitions")
-            self.cpp_info.components["diagnostic_definitions"].names["cmake_find_package"] = "diagnostic_definitions"
-            self.cpp_info.components["diagnostic_definitions"].names["cmake_find_package_multi"] = "diagnostic_definitions"
-            self.cpp_info.components["diagnostic_definitions"].names["pkg_config"] = "boost_diagnostic_definitions"  # FIXME: disable on pkg_config
             # I would assume headers also need the define BOOST_LIB_DIAGNOSTIC, as a header can trigger an autolink,
             # and this definition triggers a print out of the library selected.  See notes below on autolink and headers.
             self.cpp_info.components["headers"].requires.append("diagnostic_definitions")
@@ -1809,9 +1553,6 @@ def package_info(self):
 
             self.cpp_info.components["disable_autolinking"].libs = []
             self.cpp_info.components["disable_autolinking"].set_property("cmake_target_name", "Boost::disable_autolinking")
-            self.cpp_info.components["disable_autolinking"].names["cmake_find_package"] = "disable_autolinking"
-            self.cpp_info.components["disable_autolinking"].names["cmake_find_package_multi"] = "disable_autolinking"
-            self.cpp_info.components["disable_autolinking"].names["pkg_config"] = "boost_disable_autolinking"  # FIXME: disable on pkg_config
 
             # Even headers needs to know the flags for disabling autolinking ...
             # magic_autolink is an option in the recipe, so if a consumer wants this version of boost,
@@ -1847,9 +1588,6 @@ def package_info(self):
 
             self.cpp_info.components["dynamic_linking"].libs = []
             self.cpp_info.components["dynamic_linking"].set_property("cmake_target_name", "Boost::dynamic_linking")
-            self.cpp_info.components["dynamic_linking"].names["cmake_find_package"] = "dynamic_linking"
-            self.cpp_info.components["dynamic_linking"].names["cmake_find_package_multi"] = "dynamic_linking"
-            self.cpp_info.components["dynamic_linking"].names["pkg_config"] = "boost_dynamic_linking"  # FIXME: disable on pkg_config
             # A library that only links to Boost::headers can be linked into another library that links a Boost::library,
             # so for this reasons, the header-only library should know the BOOST_ALL_DYN_LINK definition as it will likely
             # change some important part of the boost code and cause linking errors downstream.
@@ -1974,9 +1712,6 @@ def filter_transform_module_libraries(names):
 
                 self.cpp_info.components[module].requires = self._dependencies["dependencies"][module] + ["_libboost"]
                 self.cpp_info.components[module].set_property("cmake_target_name", "Boost::" + module)
-                self.cpp_info.components[module].names["cmake_find_package"] = module
-                self.cpp_info.components[module].names["cmake_find_package_multi"] = module
-                self.cpp_info.components[module].names["pkg_config"] = f"boost_{module}"
 
                 # extract list of names of direct host dependencies to check for dependencies
                 # of components that exist in other packages