#include <iostream>
#include <type_traits>

////////////////

template <class T, class = void>
struct is_serializable : std::false_type {};

template <class T>
struct is_serializable<T, std::enable_if_t<std::is_same_v<std::ostream, std::decay_t<decltype(operator<<(std::declval<std::ostream>(), std::declval<const T&>()))>>>> : std::true_type {};

template <class T>
constexpr bool is_serializable_v = is_serializable<T>::value;

template <class ... Args>
constexpr bool all_serializable_v = (is_serializable_v<Args> && ...);

////////////////

template <class T, class = void>
struct is_deserializable : std::false_type {};

template <class T>
struct is_deserializable<T, std::enable_if_t<std::is_same_v<std::istream, std::decay_t<decltype(operator>>(std::declval<std::istream>(), std::declval<T&>()))>>>> : std::true_type {};

template <class T>
constexpr bool is_deserializable_v = is_deserializable<T>::value;

template <class ... Args>
constexpr bool all_deserializable_v = (is_deserializable_v<Args> && ...);

////////////////

class A {};

std::ostream& operator<<(std::ostream& os, const A& a) { return os; }
std::istream& operator>>(std::istream& os, A& a) { return os; }

template <class ... Args>
void serialize(Args&&... args)
{
    static_assert(all_serializable_v<Args...>, "args must have operator<<");
    // ...
}

template <class ... Args>
void deserialize(Args&&... args)
{
    static_assert(all_deserializable_v<Args...>, "args must have operator>>");
    // ...
}

int main()
{
    static_assert(is_serializable_v<int>);
    static_assert(is_deserializable_v<std::string>);

    A a;
    int b;
    double c;

    serialize(a, b, c, 4, std::string(), A());
    deserialize(a, b, c, 4, std::string(), A());
    return 0;
}