namespace
{

template<typename Type>
constexpr bool is_integer()
{
   return std::is_same_v<Type, int> // || ......;
   ;
}

template<class Container>
constexpr bool is_allow_container()
{
   using ValueType = typename std::decay_t<Container>::value_type;
   return std::is_same_v<Container, std::string> ||
          (std::is_same_v<Container, std::vector<ValueType>> && is_integer<ValueType>() ) ||
          (std::is_same_v<Container, std::list<ValueType>> && is_integer<ValueType>() );
}

} // namespace

class Class{
   template<typename Type>
   using EnableCtor = typename std::enable_if_t<is_integer<Type>() || is_allow_container<Type>()>;

   public:
   template<typename Type, class = EnableCtor<Type>>
   Class(Type&){}

   template<typename Type, class = EnableCtor<Type>>
   Class(Type&&){}

   template<typename Type, class = EnableCtor<Type>>
   Class(const Type&){}
};

int main()
{
   std::vector<int> v;
   Class a(v);

   return 0;
}

template <typename In, typename Out>
auto Fn(In&& in) -> Out;

template <>
template <typename T>
auto Fn<std::vector<T>, std::size_t>(std::vector<T>&& in) -> std::size_t {
 return in.size();
}

auto main() -> int {
   return Fn(
       std::vector<int>{1, 2, 3}
   );
}