docs: def get_all_conversion_chains(self, from_type: Type[Any] = JOKER, to_type: Type[Any] = JOKER) \
              -> Tuple[List[Converter], List[Converter], List[Converter]]:
          """
          Utility method to find matching converters or conversion chains.
  
          :param from_type: a required type of input object, or JOKER for 'wildcard'(*) .
          WARNING: "from_type=AnyObject/object/Any" means
          "all converters able to source from anything", which is different from "from_type=JOKER" which means "all
          converters whatever their source type".
          :param to_type: a required type of output object, or JOKER for 'wildcard'(*) .
          WARNING: "to_type=AnyObject/object/Any" means "all
          converters able to produce any type of object", which is different from "to_type=JOKER" which means "all
          converters whatever type they are able to produce".
          :return: a tuple of lists of matching converters, by type of *dest_type* match : generic, approximate, exact.
          The order of each list is from *less relevant* to *most relevant*
          """
  
          if from_type is JOKER and to_type is JOKER:
              matching_dest_generic = self._generic_nonstrict_conversion_chains.copy() + \
                                      self._generic_conversion_chains.copy()
              matching_dest_approx = []
              matching_dest_exact = self._specific_non_strict_conversion_chains.copy() + \
                                    self._specific_conversion_chains.copy()
  
          else:
              matching_dest_generic, matching_dest_approx, matching_dest_exact = [], [], []
  
              # first transform any 'Any' type requirement into the official class for that
              to_type = get_validated_type(to_type, 'to_type', enforce_not_joker=False)
  
              # handle generic converters first
              for c in (self._generic_nonstrict_conversion_chains + self._generic_conversion_chains):
                  match, source_exact, dest_exact = c.is_able_to_convert_detailed(strict=self.strict,
                                                                                  from_type=from_type,
                                                                                  to_type=to_type)
                  if match:
                      # match
                      if is_any_type(to_type):
                          # special case where desired to_type is already Any : in that case a generic converter will
                          # appear in 'exact match'
                          matching_dest_exact.append(c)
                      else:
                          # this is a match from a generic parser to a specific type : add in 'generic' cataegory
                          matching_dest_generic.append(c)
  
              # then the specific
              for c in (self._specific_non_strict_conversion_chains + self._specific_conversion_chains):
                  match, source_exact, dest_exact = c.is_able_to_convert_detailed(strict=self.strict,
                                                                                  from_type=from_type,
                                                                                  to_type=to_type)
                  if match:
                      if not is_any_type(to_type):
                          if dest_exact:
                              # we dont care if source is exact or approximate as long as dest is exact
                              matching_dest_exact.append(c)
                          else:
                              # this means that dest is approximate.
                              matching_dest_approx.append(c)
                      else:
                          # we only want to keep the generic ones, and they have already been added
                          pass
  
          return matching_dest_generic, matching_dest_approx, matching_dest_exact