inline
EnumType enum_deserialize(const std::string &str, EnumType defVal);

inline
EnumType enum_deserialize_##EnumType(const std::string &str);

namespace ns1
{

enum E1
{
   invalidValue = -1,
   . . .
};

enum E2
{
   invalidValue = -1,
   . . .
};

enum E3
{
   None = -42,
   . . .
};

enum E4
{
   // No invalid value defined
   Good1 = 1,
   Good2 = 2,
   Good3 = 3
};

// Comon accessor
template <typename T>
constexpr T enum_default_value(T) { return T::invalidValue; }

// Special accessor for E3
constexpr E3 enum_default_value(E3) { return E3::None; }

// Special accessor for E4
constexpr E4 enum_default_value(E4) { return {}; } // Returns zero-initialized E4 object

} // namespace ns1

namespace ns2
{

void usage_example()
{
  enum_default_value(ns1::E1{}); // returns E1::invalidValue
  enum_default_value(ns1::E2{}); // returns E2::invalidValue
  enum_default_value(ns1::E3{}); // returns E3::None
  enum_default_value(ns1::E4{}); // returns E4{}
}

} // namespace ns2

namespace ns2
{

template <typename T>
constexpr enum_default_value() { return enum_default_value(T{}); }

void usage_example()
{
  enum_default_value<ns1::E1>(); // returns E1::invalidValue
  enum_default_value<ns1::E2>(); // returns E2::invalidValue
  enum_default_value<ns1::E3>(); // returns E3::None
  enum_default_value<ns1::E4>(); // returns E4{}
}
} // namespace ns2

template <class E>
E enum_deserialize<E>(std::string_view str);

template <class E>
std::optional<E> try_enum_deserialize(std::string_view str);

template <class E>
E enum_deserialize_throwable(std::string_view str) {
  std::optional r = try_enum_deserialize<E>(str);
  return r.has_value() ? *r : throw std::domain_error(std::format("Unknown value in enum {}: {:?}", typeid(E).name(), str));
}
 
template <class E>
E enum_deserialize_or_default(std::string_view str, E default_value) {
  return try_enum_deserialize<E>(str).value_or(default_value);
}

M>inline
M>EnumType enum_deserialize(const std::string &str, EnumType defVal);
M>

  return ::my_enum_serialization::enum_deserialize_or_default(str, defVal);

M>inline
M>EnumType enum_deserialize_##EnumType(const std::string &str);
M>

EnumType e = enum_deserialize_EnumType("foo");

EnumType e = ::enum_deserialize<EnumType>("foo");

{
    auto nsGenGuard = NsGuard.parseOption(cmdLine, "namespace", std::cout);

    // Тут генерится 
    // namespace my{
    // namespace name{
    // namespace space{

    // Тут фигачим генерацию

    // Тут скоп закончился, и выводится 
    // } // namespace space
    // } // namespace name
    // } // namespace my

}

// необязательно иметь такой концепт, и необязательно реализовывать его именно так - но он пригодится
template<class E> concept MyEnumFamily = requires { enum_deserialize(std::string_view(), E::defVal); };

struct enum_desu {
  std::string_view s;

  template<MyEnumFamily E> operator E() const { return enum_deserialize(s, E::defVal); }  // эксплуатируем ADL
};

ns_a::enum_a a;
ns_b::enum_b b;
.....

a = ::enum_desu{sa};
b = ::enum_desu{sb};

Enum value to string

Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"

String to enum value

std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name);
if (color.has_value()) {
  // color.value() -> Color::GREEN
}

// case insensitive enum_cast
auto color = magic_enum::enum_cast<Color>(value, magic_enum::case_insensitive);

// enum_cast with BinaryPredicate
auto color = magic_enum::enum_cast<Color>(value, [](char lhs, char rhs) { return std::tolower(lhs) == std::tolower(rhs); }

// enum_cast with default
auto color_or_default = magic_enum::enum_cast<Color>(value).value_or(Color::NONE);

#include <magic_enum.hpp>

enum class number { one = 100, two = 200, three = 300 };

template <>
struct magic_enum::customize::enum_range<number> {
  static constexpr int min = 100;
  static constexpr int max = 300;
  // (max - min) must be less than UINT16_MAX.
};