code: public static <S1, I1, T1, SP1, TP1, S2, I2, T2, SP2, TP2> Mapping<S1, S2> copy(TSTraversalMethod method,
                                                                                      UniversalTransitionSystem<S1, ? super I1, T1, ? extends SP1, ? extends TP1> in,
                                                                                      int limit,
                                                                                      Collection<? extends I1> inputs,
                                                                                      MutableAutomaton<S2, I2, T2, ? super SP2, ? super TP2> out,
                                                                                      Function<? super I1, ? extends I2> inputsMapping,
                                                                                      Function<? super SP1, ? extends SP2> spTransform,
                                                                                      Function<? super TP1, ? extends TP2> tpTransform,
                                                                                      Predicate<? super S1> stateFilter,
                                                                                      TransitionPredicate<? super S1, ? super I1, ? super T1> transFilter) {
          Function<? super S1, ? extends SP2> spMapping =
                  (spTransform == null) ? null : TS.stateProperties(in).andThen(spTransform);
          Function<? super T1, ? extends TP2> tpMapping =
                  (tpTransform == null) ? null : TS.transitionProperties(in).andThen(tpTransform);
          return rawCopy(method, in, limit, inputs, out, inputsMapping, spMapping, tpMapping, stateFilter, transFilter);
      }
docs: Copies a {@link UniversalAutomaton} to a {@link MutableAutomaton} with possibly heterogeneous input alphabets and
  state and transition properties.
  
  @param method
  the traversal method to use
  @param in
  the input transition system
  @param limit
  the traversal limit, a value less than 0 means no limit
  @param inputs
  the inputs to consider
  @param out
  the output automaton
  @param inputsMapping
  the transformation for input symbols
  @param spTransform
  the transformation for state properties
  @param tpTransform
  the transformation for transition properties
  @param stateFilter
  the filter predicate for states
  @param transFilter
  the filter predicate for transitions
  
  @return a mapping from old to new states