diff --git a/universal/include/userver/formats/parse/try_parse.hpp b/universal/include/userver/formats/parse/try_parse.hpp
new file mode 100644
index 000000000000..5010ce8516c2
--- /dev/null
+++ b/universal/include/userver/formats/parse/try_parse.hpp
@@ -0,0 +1,115 @@
+#pragma once
+#include <type_traits>
+#include <string>
+#include <cstdint>
+#include <limits>
+#include <userver/formats/parse/to.hpp>
+#include <userver/utils/meta.hpp>
+#include <userver/utils/impl/type_list.hpp>
+#include <userver/formats/common/meta.hpp>
+#include <userver/formats/parse/common_containers.hpp>
+
+
+USERVER_NAMESPACE_BEGIN
+
+namespace formats::parse {
+
+namespace impl {
+bool CheckInBounds(const auto& x, const auto& min, const auto& max) {
+  if (x < min || x > max) {
+    return false;
+  };
+  return true;
+};
+
+} // namespace impl
+
+template <typename Value, typename T>
+inline constexpr std::optional<T> TryParse(Value&& value, To<T>) {
+  if(!value.IsObject()) {
+    return std::nullopt;
+  }
+  return value.template As<T>();
+}
+
+template <typename Value>
+inline constexpr std::optional<bool> TryParse(Value&& value, To<bool>) {
+  if(!value.IsBool()) {
+    return std::nullopt;
+  }
+  return value.template As<bool>();
+}
+template <typename Value>
+inline constexpr std::optional<double> TryParse(Value&& value, To<double>) {
+  if(!value.IsDouble()) {
+    return std::nullopt;
+  }
+  return value.template As<double>();
+}
+template <typename Value>
+inline constexpr std::optional<std::string> TryParse(Value&& value, To<std::string>) {
+  if(!value.IsString()) {
+    return std::nullopt;
+  }
+  return value.template As<std::string>();
+}
+
+template <typename Value, typename T>
+inline constexpr std::optional<T> TryParse(Value&& value, To<T>) requires meta::kIsInteger<T> {
+  constexpr auto f = [](auto response){
+    return impl::CheckInBounds(response, std::numeric_limits<T>::min(), std::numeric_limits<T>::max()) ? std::optional{static_cast<T>(response)} : std::nullopt;
+  };
+  if constexpr(std::is_unsigned_v<T>) {
+    if(!value.IsUInt64()) {
+      return std::nullopt;
+    }
+    auto response = value.template As<std::uint64_t>();
+    return f(std::move(response));
+  } else {
+    if(!value.IsInt64()) {
+      return std::nullopt;
+    }
+    auto response = value.template As<std::int64_t>();
+    return f(std::move(response));
+  }
+}
+template <typename Value, typename T>
+inline constexpr std::optional<std::vector<T>> TryParse(Value&& value, To<std::vector<T>>) {
+  if(!value.IsArray()) {
+    return std::nullopt;
+  }
+  std::vector<T> response;
+  response.reserve(value.GetSize());
+  for(const auto& item : value) {
+    auto insert = TryParse(item, To<T>{});
+    if(!insert) {
+      return std::nullopt;
+    }
+    response.push_back(std::move(*insert));
+  }
+  return response;
+}
+
+template <typename T, typename Value>
+constexpr inline std::optional<std::optional<T>> TryParse(Value&& value, To<std::optional<T>>) {
+  if (value.IsMissing() || value.IsNull()) {
+    return std::optional<T>{std::nullopt};
+  }
+  return TryParse(value, To<T>{});
+}
+
+template <typename Value>
+constexpr inline std::optional<float> TryParse(Value&& value, To<float>) {
+  auto response = value.template As<double>();
+  if(impl::CheckInBounds(response, std::numeric_limits<float>::lowest(),
+                        std::numeric_limits<float>::max())) {
+    return static_cast<float>(response);
+  }
+  return std::nullopt;
+}
+
+
+
+} // namespace formats::parse
+
+USERVER_NAMESPACE_END
diff --git a/universal/include/userver/formats/universal/common_containers.hpp b/universal/include/userver/formats/universal/common_containers.hpp
new file mode 100644
index 000000000000..1b25d346f202
--- /dev/null
+++ b/universal/include/userver/formats/universal/common_containers.hpp
@@ -0,0 +1,360 @@
+#if __cplusplus >= 202002L
+#pragma once
+#include <userver/formats/universal/universal.hpp>
+#include <userver/formats/common/items.hpp>
+#include <userver/formats/parse/try_parse.hpp>
+#include <format>
+#include <unordered_map>
+#include <userver/utils/regex.hpp>
+
+USERVER_NAMESPACE_BEGIN
+namespace formats::universal {
+template <typename T>
+struct Max : public impl::Param<T> {
+  inline constexpr Max(const T& value) :
+      impl::Param<T>(value) {}
+  inline constexpr std::optional<std::string> Check(const T& value) const {
+    if(value <= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
+  }
+  inline constexpr std::string Error(const T& value) const {
+    return std::format("{} > {}", value, this->value);
+  }
+};
+
+
+struct MinElements : public impl::Param<std::size_t> {
+  inline constexpr MinElements(const std::size_t& value) :
+      impl::Param<std::size_t>(value) {}
+  template <typename Value>
+  inline constexpr auto Check(const Value& value) const -> std::optional<std::string> {
+    if(value.size() >= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
+  }
+  template <typename Value>
+  inline constexpr auto Error(const Value&) const {
+    return "Error";
+  }
+};
+struct MaxElements : public impl::Param<std::size_t> {
+  inline constexpr MaxElements(const std::size_t& value) :
+      impl::Param<std::size_t>(value) {}
+  template <typename Value>
+  inline constexpr auto Check(const Value& value) const -> std::optional<std::string> {
+    if(value.size() <= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
+  }
+  template <typename Value>
+  inline constexpr auto Error(const Value&) const {
+    return "Error";
+  }
+};
+
+template <typename T>
+struct Min : public impl::Param<T> {
+  inline constexpr Min(const T& value) :
+      impl::Param<T>(value) {}
+  inline constexpr std::optional<std::string> Check(const T& value) const {
+    if(value >= this->value) {
+      return std::nullopt;
+    }
+    return this->Error(value);
+  }
+  inline constexpr auto Error(const T& value) const {
+    return std::format("{} < {}", value, this->value);
+  }
+};
+template <typename T, typename = void>
+struct Default : public impl::EmptyCheck, private impl::Param<T(*)()> {
+  inline constexpr Default(T (*ptr)()) :
+      impl::Param<T(*)()>(ptr) {}
+  inline constexpr Default(auto f) requires requires {static_cast<T(*)()>(f);} :
+      impl::Param<T(*)()>(static_cast<T(*)()>(f)) {}
+  inline constexpr auto value() const {
+    return static_cast<const impl::Param<T(*)()>&>(*this).value();
+  }
+};
+
+template <typename T>
+struct Default<T, std::enable_if_t<std::is_arithmetic_v<T>>> : public impl::EmptyCheck, private impl::Param<T> {
+  inline constexpr Default(const T& value) :
+      impl::Param<T>(value) {}
+  inline constexpr auto value() const {
+    return static_cast<const impl::Param<T>&>(*this).value;
+  }
+};
+template <>
+struct Default<std::string, void> : public impl::EmptyCheck, private impl::Param<std::string_view> {
+  inline constexpr Default(std::string_view value) :
+      impl::Param<std::string_view>(value) {}
+  template <std::size_t N>
+  inline constexpr Default(const char(&value)[N]) :
+      impl::Param<std::string_view>(value) {}
+  inline constexpr auto value() const -> std::string {
+    return static_cast<std::string>(static_cast<const impl::Param<std::string_view>&>(*this).value);
+  }
+};
+
+
+template <utils::ConstexprString Pattern>
+static const utils::regex kRegex(Pattern);
+
+struct Pattern : public impl::EmptyCheck, public impl::Param<const utils::regex*> {
+  constexpr inline Pattern(const utils::regex& regex) :
+      impl::Param<const utils::regex*>(&regex) {}
+  constexpr inline std::optional<std::string> Check(std::string_view str) const {
+    if(utils::regex_match(str, *this->value)) {
+      return std::nullopt;
+    }
+    return this->Error(str);
+  }
+  constexpr inline std::string Error(std::string_view) const {
+    return "Error";
+  }
+};
+
+struct AdditionalProperties : public impl::EmptyCheck, public impl::Param<bool> {
+  constexpr inline AdditionalProperties(const bool& value) :
+      impl::Param<bool>(value) {}
+};
+
+template <typename T>
+struct FieldConfig<std::optional<T>> {
+  FieldConfig<T> Main = {};
+  std::optional<Default<T>> Default = std::nullopt;
+  bool Required = false;
+  bool Nullable = false;
+  static inline constexpr auto Checker(const auto& check, const auto& value) -> std::optional<std::string> 
+      requires requires{check.Check(*value);} {
+    if(value) {
+      return check.Check(*value);
+    };
+    return std::nullopt;
+  }; 
+  constexpr inline std::optional<std::string> Check(const std::optional<T>& value) const {
+    if(value) {
+      return this->Main.Check(*value);
+    };
+    return std::nullopt;
+  }
+  constexpr auto Write(const std::optional<T>& value, std::string_view field_name, const auto& names, auto& builder) const {
+    if(value) {
+      this->Main.Write(*value, field_name, names, builder);
+      return;
+    }
+    if(this->Default) {
+      this->Main.Write(this->Default->value(), field_name, names, builder);
+      return;
+    }
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::optional<T> Read(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    if(this->Required && value[name].IsMissing()) {
+      using Type = std::remove_reference_t<Value>;
+      throw typename Type::Exception{fmt::format("required, !nullable was violated in {}", value.GetPath())};
+    }
+    if(!value[name].IsMissing()) {
+      return this->Nullable 
+      ? (value[name].IsNull()
+        ? std::nullopt
+        : std::optional{this->Main.template Read<MainClass, I>(std::forward<Value>(value))})
+      : std::optional{this->Main.template Read<MainClass, I>(std::forward<Value>(value))};
+    }
+    if(this->Default) {
+      return this->Default->value();
+    }
+    return std::nullopt;
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::optional<std::optional<T>> TryRead(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    if(value[name].IsMissing() && this->Required) {
+      return std::nullopt;
+    }
+    if(!this->Nullable) {
+      if(value[name].IsNull()) {
+        return std::nullopt;
+      }
+    }
+    if(this->Default && (value[name].IsMissing() || value[name].IsNull())) {
+      return this->Default->value();
+    }
+    return this->Main.template TryRead<MainClass, I>(std::forward<Value>(value));
+  }
+};
+
+template <typename T>
+struct FieldConfig<T, std::enable_if_t<meta::kIsInteger<T> || std::is_floating_point_v<T>>> {
+  std::optional<Max<T>> Maximum = std::nullopt;
+  std::optional<Min<T>> Minimum = std::nullopt;
+  template <typename MainClass, auto I, typename Value>
+  constexpr int Read(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return value[name].template As<T>();
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::optional<T> TryRead(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return parse::TryParse(value[name], parse::To<T>{});
+  }
+  constexpr auto Write(const int& value, std::string_view field_name, const auto&, auto& builder) const {
+    builder[static_cast<std::string>(field_name)] = value;
+  }
+  inline constexpr std::optional<std::string> Check(const int&) const {
+    return std::nullopt;
+  }
+};
+template <>
+struct FieldConfig<std::string> {
+  std::optional<Pattern> Pattern = std::nullopt;
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::string Read(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return value[name].template As<std::string>();
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::optional<std::string> TryRead(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return parse::TryParse(value[name], parse::To<std::string>{});
+  }
+  constexpr auto Write(std::string_view value, std::string_view field_name, const auto&, auto& builder) const {
+    builder[static_cast<std::string>(field_name)] = value;
+  }
+  inline constexpr std::optional<std::string> Check(std::string_view) const {
+    return std::nullopt;
+  }
+
+};
+
+template <typename Value>
+struct FieldConfig<std::unordered_map<std::string, Value>> {
+  std::optional<AdditionalProperties> AdditionalProperties = std::nullopt;
+  FieldConfig<Value> Items = {};
+  using Type = std::unordered_map<std::string, Value>;
+  template <typename MainClass, auto I, typename Value2>
+  inline constexpr Type Read(Value2&& value) const {
+    Type response;
+    if(this->AdditionalProperties) {
+      constexpr auto fields = boost::pfr::names_as_array<MainClass>();
+      for(const auto& [name, value] : userver::formats::common::Items(std::forward<Value2>(value))) {
+        auto it = std::find(fields.begin(), fields.end(), name);
+        if(it == fields.end()) {
+          response.emplace(name, value.template As<Value>());
+        }
+      }
+      return response;
+    }
+    constexpr auto fieldName = boost::pfr::get_name<I, MainClass>();
+    for(const auto& [name, value] : userver::formats::common::Items(value[fieldName])) {
+      response.emplace(name, value.template As<Value>());
+    }
+    return response;
+  }
+  template <typename MainClass, auto I, typename Value2>
+  inline constexpr std::optional<Type> TryRead(Value2&& value) const {
+    Type response;
+    if(this->AdditionalProperties) {
+      constexpr auto fields = boost::pfr::names_as_array<MainClass>();
+      for(const auto& [name, value] : userver::formats::common::Items(std::forward<Value2>(value))) {
+        if(std::find(fields.begin(), fields.end(), name) == fields.end()) {
+          auto New = parse::TryParse(value, parse::To<Value>{});
+          if(!New) {
+            return std::nullopt;
+          }
+          response.emplace(name, *New);
+        }
+      }
+      return response;
+    }
+    constexpr auto field_name = boost::pfr::get_name<I, MainClass>();
+    for(const auto& [name, value] : userver::formats::common::Items(value[field_name])) {
+      auto New = parse::TryParse(value, parse::To<Value>{});
+      if(!New) {
+        return std::nullopt;
+      }
+      response.emplace(name, *New);
+    }
+    return response;
+  }
+  inline constexpr std::optional<std::string> Check(const Type& map) const {
+    std::optional<std::string> error;
+    for(const auto& [key, value] : map) {
+      auto add = impl::UniversalCheckField(value, this->Items);
+      if(add) {
+        if(!error) {
+          error = add;
+          continue;
+        }
+        *error += *add;
+      }
+    }
+    return error;
+  }
+  template <typename Builder>
+  constexpr auto Write(const Type& value, std::string_view field_name, const auto&, Builder& builder) const {
+    if(this->AdditionalProperties) {
+      for(const auto& [name, value2] : value) {
+        builder[name] = value2;
+      }
+      return;
+    }
+    Builder newBuilder;
+    for(const auto& [name, value2] : value) {
+      newBuilder[name] = value2;
+    }
+    builder[static_cast<std::string>(field_name)] = newBuilder.ExtractValue();
+  }
+};
+template <typename Element>
+struct FieldConfig<std::vector<Element>> {
+  std::optional<MinElements> MinimalElements = std::nullopt;
+  FieldConfig<Element> Items = {};
+  template <typename MainClass, auto I, typename Value>
+  inline constexpr auto Read(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    std::vector<Element> response;
+    for(const auto& element : value[name]) {
+      auto New = element.template As<Element>();
+      response.push_back(std::move(New));
+    }
+    return response;
+  }
+  template <typename MainClass, auto I, typename Value>
+  inline constexpr std::optional<std::vector<Element>> TryRead(Value&& value) const {
+    std::vector<Element> response;
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    for(const auto& element : value[name]) {
+      auto New = parse::TryParse(element, parse::To<Element>{});
+      if(!New) {
+        return std::nullopt;
+      }
+      response.push_back(std::move(*New));
+    }
+    return response;
+  }
+  inline constexpr std::optional<std::string> Check(const std::vector<Element>& obj) const {
+    std::optional<std::string> error = std::nullopt;
+    for(const auto& element : obj) {
+      auto add = impl::UniversalCheckField(element, this->Items);
+      if(add) {
+        if(!error) {
+          error = add;
+          continue;
+        }
+        *error += *add;
+      }
+    }
+    return error;
+  }
+
+};
+} // namespace formats::universal
+USERVER_NAMESPACE_END
+#endif
diff --git a/universal/include/userver/formats/universal/universal.hpp b/universal/include/userver/formats/universal/universal.hpp
new file mode 100644
index 000000000000..19b85ed0f695
--- /dev/null
+++ b/universal/include/userver/formats/universal/universal.hpp
@@ -0,0 +1,371 @@
+#if __cplusplus >= 202002L
+#pragma once
+#include <userver/utils/constexpr_string.hpp>
+#include <userver/formats/parse/to.hpp>
+#include <userver/formats/parse/try_parse.hpp>
+#include <userver/formats/serialize/to.hpp>
+#include <userver/utils/meta.hpp>
+#include <userver/utils/trivial_map.hpp>
+#include <userver/utils/overloaded.hpp>
+#include <variant>
+#include <type_traits>
+#include <boost/pfr/core.hpp>
+#include <boost/pfr/core_name.hpp>
+#include <boost/lexical_cast.hpp>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace formats::universal {
+
+
+template <typename T, typename Enable = void>
+struct FieldConfig {
+  constexpr inline std::optional<std::string> Check(const T&) const {
+    return std::nullopt;
+  }
+  constexpr auto Write(const T& value, std::string_view field_name, const auto&, auto& builder) const {
+    builder[static_cast<std::string>(field_name)] = value;
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr T Read(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return value[name].template As<T>();
+  }
+  template <typename MainClass, auto I, typename Value>
+  constexpr std::optional<T> TryRead(Value&& value) const {
+    constexpr auto name = boost::pfr::get_name<I, MainClass>();
+    return parse::TryParse(value[name], parse::To<T>{});
+  }
+};
+namespace impl {
+
+template <typename T, std::size_t I>
+using kFieldTypeOnIndex = std::remove_reference_t<decltype(boost::pfr::get<I>(std::declval<T>()))>;
+
+template <typename T>
+consteval std::size_t getFieldIndexByName(std::string_view field_name) {
+  constexpr auto names = boost::pfr::names_as_array<T>();
+  return std::find(names.begin(), names.end(), field_name) - names.begin();
+}
+
+struct Disabled {};
+
+
+template <typename T>
+struct Param {
+  T value;
+  constexpr Param(const T& value) :
+      value(value) {}
+};
+
+template <auto Value>
+struct Wrapper {
+  static constexpr auto kValue = Value;
+};
+
+template <typename... Args>
+inline constexpr std::optional<std::string> Add(Args&&... args) {
+  std::optional<std::string> result;
+  ([&]<typename T>(T&& arg){
+    if(arg) {
+      if(!result) {
+        result.emplace(*std::forward<T>(arg));
+        return;
+      }
+      result->append(*std::forward<T>(arg));
+    }
+  }(std::forward<Args>(args)), ...);
+  return result;
+}
+
+template <typename T, typename TT>
+inline constexpr auto checkCaller(T&& response, TT&& check) 
+        requires (requires{FieldConfig<std::remove_cvref_t<T>>::Checker(check, response);} 
+                || requires{check.Check(std::forward<T>(response));}) {
+  using Type = FieldConfig<std::remove_cvref_t<T>>;
+  if constexpr(requires{Type::Checker(check, response);}) {
+    return Type::Checker(std::forward<TT>(check), response);
+  } else {
+    return check.Check(std::forward<T>(response));
+  }
+}
+
+template <typename T>
+using RemoveOptional = decltype(utils::Overloaded(
+    []<typename TT>(const std::optional<TT>&) -> TT {},
+    [](auto&&) -> T {}
+  )(std::declval<const T&>()));
+
+
+template <typename T, typename FieldConfigType>
+inline constexpr std::optional<std::string> UniversalCheckField(
+          T&& response,
+          FieldConfig<FieldConfigType> config) {
+  auto error = [&]<auto... Is>(std::index_sequence<Is...>) -> std::optional<std::string> {
+    return Add([&]<auto II>(Wrapper<II>) -> std::optional<std::string> {
+      const auto& check = boost::pfr::get<II>(config);
+      using CheckType = std::remove_cvref_t<decltype(check)>;
+      if constexpr(requires(RemoveOptional<CheckType> ch){checkCaller(response, ch);}) {
+        if constexpr(meta::kIsOptional<CheckType>) {
+          if(check) {
+            std::optional error = checkCaller(response, *check);
+            if(error) {
+              return error;
+            }
+          }
+        } else {
+          std::optional error = checkCaller(response, check);
+          if(error) {
+            return error;
+          }
+        }
+      }
+      return std::nullopt;
+    }(Wrapper<Is>{})...);
+  }(std::make_index_sequence<boost::pfr::tuple_size_v<decltype(config)>>());
+  if constexpr(meta::kIsOptional<std::remove_cvref_t<T>>) {
+    if(response) {
+      auto add = config.Check(*response);
+      if(error) {
+        if(add) {
+          *error += *add;
+        }
+        return error;
+      }
+      error = add;
+    }
+  } else {
+    auto add = config.Check(std::forward<T>(response));
+    if(error) {
+      if(add) {
+        *error += *add;
+      }
+      return error;
+    }
+    error = add;
+  }
+  return error;
+}
+
+
+template <typename MainClass, auto I, typename T>
+inline constexpr auto UniversalParseField(
+          T&& value,
+          FieldConfig<kFieldTypeOnIndex<MainClass, I>> config) {
+  auto response = config.template Read<MainClass, I>(value);
+  std::optional error = UniversalCheckField(response, config);
+  if(error) {
+    throw std::runtime_error(std::move(*error));
+  }
+  return response;
+}
+
+template <typename MainClass, auto I, typename T>
+inline constexpr auto UniversalTryParseField(
+          T&& value,
+          FieldConfig<kFieldTypeOnIndex<MainClass, I>> config) {
+  auto response = config.template TryRead<MainClass, I>(value);
+  return [&]() -> decltype(response) {
+    if(!UniversalCheckField(response, std::move(config))) {
+      return response;
+    }
+    return std::nullopt;
+  }();
+}
+
+template <typename MainClass, auto I, typename T, typename Builder>
+inline constexpr auto UniversalSerializeField(
+        T&& value,
+        Builder& builder,
+        FieldConfig<kFieldTypeOnIndex<MainClass, I>> config) {
+  std::optional error = UniversalCheckField(value, config);
+  if(error) {
+    throw std::runtime_error(std::move(*error));
+  }
+  config.Write(std::forward<T>(value), boost::pfr::get_name<I, MainClass>(), boost::pfr::names_as_array<MainClass>(), builder);
+}
+struct EmptyCheck {
+  template <typename Value>
+  inline constexpr std::optional<std::string> Check(Value&&) const {
+    return std::nullopt;
+  }
+};
+
+template <typename T>
+concept kEnabled = !(std::same_as<std::remove_cvref_t<T>, Disabled>);
+
+
+
+} // namespace impl
+
+template <typename T>
+inline constexpr impl::Disabled kSerialization;
+
+template <typename T>
+inline constexpr auto kDeserialization = kSerialization<T>;
+
+
+template <typename T>
+class SerializationConfig {
+  using FieldsConfigType = decltype([]<auto... I>(std::index_sequence<I...>){
+    return std::type_identity<std::tuple<FieldConfig<impl::kFieldTypeOnIndex<T, I>>...>>();
+  }(std::make_index_sequence<boost::pfr::tuple_size_v<T>>()))::type;
+
+  public:
+    template <utils::ConstexprString fieldName>
+    inline constexpr auto& With(FieldConfig<impl::kFieldTypeOnIndex<T, impl::getFieldIndexByName<T>(fieldName)>>&& field_config) {
+      constexpr auto Index = impl::getFieldIndexByName<T>(fieldName);
+      std::get<Index>(this->fields_config) = std::move(field_config);
+      return *this;
+    }
+    inline constexpr SerializationConfig() = default;
+
+    template <std::size_t I>
+    inline constexpr auto Get() const {
+      return std::get<I>(this->fields_config);
+    }
+  private:
+    FieldsConfigType fields_config = {};
+};
+
+template <typename... Ts>
+class SerializationConfig<std::variant<Ts...>> {
+  public:
+    template <std::size_t I>
+    inline constexpr auto& With(FieldConfig<decltype(Get<I>(utils::impl::TypeList<Ts...>{}))>&& field_config) {
+      std::get<I>(this->variant_config) = std::move(field_config);
+      return *this;
+    }
+    template <typename T>
+    inline constexpr auto& With(FieldConfig<T>&& field_config) {
+      return this->With<Find<T>(utils::impl::TypeList<Ts...>{})>(std::move(field_config));
+    }
+    inline constexpr SerializationConfig() = default;
+  private:
+    std::tuple<FieldConfig<Ts>...> variant_config = {};
+};
+
+
+} // namespace formats::universal
+
+
+namespace formats::enums {
+
+template <typename T>
+inline constexpr auto kEnumMapping = universal::impl::Disabled{};
+
+
+} // namespace formats::enums
+
+namespace formats::parse {
+
+template <typename To>
+inline constexpr auto ParseFromString(std::string_view from) -> To {
+  return boost::lexical_cast<To>(from);
+}
+
+template <>
+inline constexpr auto ParseFromString<std::string_view>(std::string_view from) -> std::string_view {
+  return from;
+};
+
+template <typename T>
+inline constexpr auto ParseFromString(std::string_view value) -> T
+    requires universal::impl::kEnabled<decltype(enums::kEnumMapping<T>)> {
+  using M = decltype(enums::kEnumMapping<std::remove_cvref_t<T>>);
+  auto response = enums::kEnumMapping<T>.TryFind(ParseFromString<typename M::template MappedTypeFor<T>>(value));
+  if(!response) {
+    throw std::runtime_error{"Can't serialize enum to string"};
+  }
+  return *std::move(response);
+}
+
+template <typename Value, typename T>
+inline constexpr auto Parse(Value&& value, To<T>) -> T
+      requires universal::impl::kEnabled<decltype(universal::kDeserialization<T>)> {
+  return [&]<auto... I>(std::index_sequence<I...>){
+    auto config = universal::kDeserialization<T>;
+    return T{universal::impl::UniversalParseField<T, I>(value, config.template Get<I>())...};
+  }(std::make_index_sequence<boost::pfr::tuple_size_v<T>>());
+}
+
+template <typename Value, typename T>
+inline constexpr auto Parse(Value&& value, To<T>) -> T
+    requires universal::impl::kEnabled<decltype(enums::kEnumMapping<T>)> {
+  using M = decltype(enums::kEnumMapping<T>);
+  constexpr auto f = [](auto response){
+    if(response) {
+      return *response;
+    };
+    throw std::runtime_error("Can't Parse to enum");
+  };
+  if constexpr(std::same_as<typename M::template MappedTypeFor<T>, std::string_view>) {
+    return f(enums::kEnumMapping<T>.TryFind(value.template As<std::string>()));
+  } else {
+    return f(enums::kEnumMapping<T>.TryFind(value.template As<typename M::template MappedTypeFor<T>>()));
+  };
+}
+
+template <typename Value, typename T>
+inline constexpr auto TryParse(Value&& value, To<T>) -> std::optional<T>
+      requires universal::impl::kEnabled<decltype(universal::kDeserialization<T>)> {
+  return [&]<auto... I>(std::index_sequence<I...>) -> std::optional<T> {
+    auto config = universal::kDeserialization<T>;
+    auto tup = std::make_tuple(universal::impl::UniversalTryParseField<T, I>(value, config.template Get<I>())...);
+    if((std::get<I>(tup) && ...)) {
+      return T{*std::get<I>(tup)...};
+    }
+    return std::nullopt;
+  }(std::make_index_sequence<boost::pfr::tuple_size_v<T>>());
+}
+
+} // namespace formats::parse
+namespace formats::serialize {
+
+template <typename From>
+inline constexpr auto ToString(From&& from) -> std::string {
+  return std::to_string(std::forward<From>(from));
+}
+
+inline constexpr auto ToString(std::string_view from) -> std::string {
+  return static_cast<std::string>(from);
+};
+
+template <typename T>
+inline constexpr auto ToString(T&& value) -> std::string 
+    requires universal::impl::kEnabled<decltype(enums::kEnumMapping<std::remove_cvref_t<T>>)> {
+  auto response = enums::kEnumMapping<std::remove_cvref_t<T>>.TryFind(std::forward<T>(value));
+  if(!response) {
+    throw std::runtime_error{"Can't serialize enum to string"};
+  }
+  return ToString(*std::move(response));
+}
+
+
+
+template <typename Value, typename T>
+inline constexpr auto Serialize(T&& obj, To<Value>) -> Value 
+    requires universal::impl::kEnabled<decltype(enums::kEnumMapping<std::remove_cvref_t<T>>)> {
+  auto finded = enums::kEnumMapping<std::remove_cvref_t<T>>.TryFind(std::forward<T>(obj));
+  if(!finded) {
+    throw std::runtime_error("Can't serialize enum");
+  }
+  return typename Value::Builder(*std::move(finded)).ExtractValue();
+}
+
+template <typename Value, typename T>
+inline constexpr auto Serialize(T&& obj, To<Value>) -> Value 
+      requires universal::impl::kEnabled<decltype(universal::kSerialization<std::remove_cvref_t<T>>)> {
+  using Type = std::remove_cvref_t<T>;
+  return [&]<auto... I>(std::index_sequence<I...>){
+    typename Value::Builder builder;
+    auto config = universal::kSerialization<Type>;
+    (universal::impl::UniversalSerializeField<Type, I>(boost::pfr::get<I>(obj), builder, config.template Get<I>()), ...);
+    return builder.ExtractValue();
+  }(std::make_index_sequence<boost::pfr::tuple_size_v<Type>>());
+}
+
+} // namespace formats::serialize
+
+USERVER_NAMESPACE_END
+#endif
diff --git a/universal/include/userver/utils/constexpr_string.hpp b/universal/include/userver/utils/constexpr_string.hpp
new file mode 100644
index 000000000000..9f48253490a1
--- /dev/null
+++ b/universal/include/userver/utils/constexpr_string.hpp
@@ -0,0 +1,62 @@
+#if __cplusplus >= 202002L
+#pragma once
+#include <algorithm>
+#include <string>
+#include <array>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace utils {
+
+template <std::size_t Size>
+struct ConstexprString {
+
+  static constexpr auto kSize = Size;
+  constexpr operator std::string_view() const {
+    return std::string_view{this->contents_.data(), Size - 1};
+  };
+  constexpr auto c_str() const -> const char* {
+    return this->contents_.data();
+  };
+  constexpr std::size_t size() const {
+    return Size - 1;
+  };
+  constexpr const char* data() const {
+    return this->contents_.begin();
+  };
+
+  constexpr operator char&() const {
+    return this->contents_.data();
+  };
+
+  friend constexpr bool operator==(const ConstexprString& string, const char* other) {
+    return std::string_view(string) == std::string_view(other);
+  };
+  template <typename Stream>
+  friend constexpr auto& operator<<(Stream& stream, const ConstexprString& string) {
+    stream << static_cast<std::string_view>(string);
+    return stream;
+  };
+
+  constexpr ConstexprString(const char (&str)[Size]) noexcept {
+    std::copy_n(str, Size, std::begin(this->contents_));
+  };
+  constexpr ConstexprString(std::array<char, Size> data) noexcept : contents_(data) {};
+  template <std::size_t OtherSize>
+  constexpr ConstexprString<Size + OtherSize> operator+(const ConstexprString<OtherSize>& other) const noexcept {
+    return
+        [&]<auto... I, auto... I2>(std::index_sequence<I...>, std::index_sequence<I2...>){
+      return ConstexprString<Size + OtherSize>({this->contents_[I]..., other.contents_[I2]...});
+    }(std::make_index_sequence<Size>(), std::make_index_sequence<OtherSize>());
+  };
+  template <std::size_t OtherSize>
+  constexpr ConstexprString<Size + OtherSize> operator+(const char(&str)[OtherSize]) const noexcept {
+    return *this + ConstexprString<OtherSize>{str};
+  };
+  std::array<char, Size> contents_;
+};
+template <std::size_t n>
+ConstexprString(char const (&)[n]) -> ConstexprString<n>;
+} // namespace utils
+USERVER_NAMESPACE_END
+#endif
diff --git a/universal/include/userver/utils/impl/type_list.hpp b/universal/include/userver/utils/impl/type_list.hpp
new file mode 100644
index 000000000000..dc9e13a9e95a
--- /dev/null
+++ b/universal/include/userver/utils/impl/type_list.hpp
@@ -0,0 +1,58 @@
+#pragma once
+#include <type_traits>
+#include <utility>
+
+USERVER_NAMESPACE_BEGIN
+
+namespace utils::impl {
+
+template <typename... T>
+struct TypeList {};
+
+
+template <typename... Ts>
+consteval auto Size(TypeList<Ts...>) {
+  return sizeof...(Ts);
+}
+
+template <template <typename...> typename Check, typename... Ts>
+consteval auto AnyOf(TypeList<Ts...>) {
+  return (Check<Ts>::value || ...);
+}
+
+
+template <typename Check, typename... Ts>
+constexpr auto AnyOf(Check check, TypeList<Ts...>) {
+  return (check(std::type_identity<Ts>()) || ...);
+}
+
+template <typename T>
+consteval auto IsSameCarried() {
+  return []<typename T2>(std::type_identity<T2>){
+    return std::is_same_v<T, T2>;
+  };
+}
+template <typename T>
+consteval auto IsConvertableCarried() {
+  return []<typename T2>(std::type_identity<T2>){
+    return std::is_convertible_v<T, T2>;
+  };
+}
+
+struct Caster {
+  inline constexpr Caster(auto) {}
+  inline constexpr Caster() = default;
+};
+
+template <std::size_t... Is, typename T>
+consteval auto Get(std::index_sequence<Is...>, decltype(Is, Caster())..., T&& arg, ...) -> T; 
+
+template <std::size_t I, typename... Ts>
+consteval auto Get(const TypeList<Ts...>&) -> decltype(Get(std::make_index_sequence<I>(), std::declval<Ts>()...));
+
+
+
+} // namespace utils::impl
+
+USERVER_NAMESPACE_END
+
diff --git a/universal/src/formats/json/universal_test.cpp b/universal/src/formats/json/universal_test.cpp
new file mode 100644
index 000000000000..c8c028b82c46
--- /dev/null
+++ b/universal/src/formats/json/universal_test.cpp
@@ -0,0 +1,351 @@
+#if __cplusplus >= 202002L
+#include <gtest/gtest.h>
+#include <userver/formats/universal/common_containers.hpp>
+#include <userver/formats/json.hpp>
+
+
+USERVER_NAMESPACE_BEGIN
+
+struct SomeStruct {
+  int field1;
+  int field2;
+  inline constexpr bool operator==(const SomeStruct& other) const = default;
+};
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct> =
+    SerializationConfig<SomeStruct>();
+
+TEST(Serialize, Basic) {
+  SomeStruct a{10, 100};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(formats::json::ToString(json), R"({"field1":10,"field2":100})");
+};
+
+TEST(Parse, Basic) {
+  const auto json = formats::json::FromString(R"({"field1":10,"field2":100})");
+  const auto fromJson = json.As<SomeStruct>();
+  constexpr SomeStruct valid{10, 100};
+  EXPECT_EQ(fromJson, valid);
+};
+
+TEST(TryParse, Basic) {
+  const auto json = formats::json::FromString(R"({"field1":10,"field2":100})");
+  const auto json2 = formats::json::FromString(R"({"field1":10,"field3":100})");
+  const auto json3 = formats::json::FromString(R"({"field1":10,"field2":"100"})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json,  formats::parse::To<SomeStruct>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct>{}), false);
+};
+
+
+struct SomeStruct2 {
+  std::optional<int> field1 = std::nullopt;
+  std::optional<int> field2 = std::nullopt;
+  std::optional<int> field3 = std::nullopt;
+  std::optional<std::string> field4 = std::nullopt;
+  constexpr bool operator==(const SomeStruct2& other) const noexcept {
+    return this->field1 == other.field1 && this->field2 == other.field2 && this->field3 == other.field3 && this->field4 == other.field4;
+  };
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct2> =
+    SerializationConfig<SomeStruct2>()
+    .With<"field1">({.Default = 114})
+    .With<"field4">({.Default = "42"});
+
+
+TEST(Serialize, Optional) {
+  SomeStruct2 a{.field2 = 100};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(json, formats::json::FromString(R"({"field1":114,"field2":100,"field4":"42"})"));
+};
+TEST(Parse, Optional) {
+  SomeStruct2 valid{.field1 = 114, .field4 = {{"42"}}};
+  const auto json = formats::json::FromString("{}");
+  EXPECT_EQ(json.As<SomeStruct2>(), valid);
+};
+
+TEST(TryParse, Optional) {
+  const auto json = formats::json::FromString("{}");
+  SomeStruct2 valid{.field1 = 114, .field4 = {{"42"}}};
+  EXPECT_EQ(formats::parse::TryParse(json, formats::parse::To<SomeStruct2>{}), valid);
+  const auto json2 = formats::json::FromString(R"({"field1": ""})");
+  SomeStruct2 valid2{.field4 = {{"42"}}};
+  EXPECT_EQ(formats::parse::TryParse(json2, formats::parse::To<SomeStruct2>{}), valid2);
+
+};
+
+
+struct SomeStruct3 {
+  std::unordered_map<std::string, int> field;
+  inline bool operator==(const SomeStruct3& other) const = default;
+};
+
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct3> =
+    SerializationConfig<SomeStruct3>()
+    .With<"field">({.AdditionalProperties = true});
+
+TEST(Serialize, Additional) {
+  std::unordered_map<std::string, int> value;
+  value["data1"] = 1;
+  value["data2"] = 2;
+  SomeStruct3 a{value};
+  const auto json = formats::json::ValueBuilder(a).ExtractValue();
+  EXPECT_EQ(json, formats::json::FromString(R"({"data1":1,"data2":2})"));
+};
+
+TEST(Parse, Additional) {
+  std::unordered_map<std::string, int> value;
+  value["data1"] = 1;
+  value["data2"] = 2;
+  SomeStruct3 valid{value};
+  const auto json = formats::json::FromString(R"({"data1":1,"data2":2})");
+  const auto fromJson = json.As<SomeStruct3>();
+  EXPECT_EQ(valid, fromJson);
+};
+
+TEST(TryParse, Additional) {
+  const auto json = formats::json::FromString(R"({"data1":1,"data2":2})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<SomeStruct3>{}), true);
+};
+
+struct SomeStruct4 {
+  int field;
+  inline constexpr bool operator==(const SomeStruct4& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct4> =
+    SerializationConfig<SomeStruct4>()
+    .With<"field">({.Maximum = 120, .Minimum = 10});
+
+
+
+
+TEST(TryParse, MinMax) {
+  const auto json =  formats::json::FromString(R"({"field":1})");
+  const auto json2 = formats::json::FromString(R"({"field":11})");
+  const auto json3 = formats::json::FromString(R"({"field":121})");
+
+  EXPECT_EQ((bool)formats::parse::TryParse(json,  formats::parse::To<SomeStruct4>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct4>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct4>{}), false);
+};
+
+
+
+struct SomeStruct5 {
+  std::string field;
+  inline constexpr bool operator==(const SomeStruct5& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct5> =
+    SerializationConfig<SomeStruct5>()
+    .With<"field">({.Pattern = kRegex<"^[0-9]+$">});
+
+TEST(TryParse, Pattern) {
+  const auto json =  formats::json::FromString(R"({"field":"1234412"})");
+  const auto json2 = formats::json::FromString(R"({"field":"abcdefgh"})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json,  formats::parse::To<SomeStruct5>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct5>{}), false);
+};
+
+
+
+TEST(TryParse, null) {
+  const auto json = formats::json::FromString("null");
+  EXPECT_EQ((bool)formats::parse::TryParse(json, formats::parse::To<std::optional<int>>{}), true);
+};
+
+struct SomeStruct6 {
+  std::vector<std::vector<int>> field;
+  inline constexpr bool operator==(const SomeStruct6& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct6> =
+    SerializationConfig<SomeStruct6>()
+    .With<"field">({.MinimalElements = 2, .Items = {.MinimalElements = 1, .Items = {.Minimum = 10}}});
+
+TEST(TryParse, Arrays) {
+  const auto json =  formats::json::FromString(R"({"field":[[10], [20]]})");
+  const auto json2 = formats::json::FromString(R"({"field":[["10"], [20]]})");
+  const auto json3 = formats::json::FromString(R"({"field":[[9], [20]]})");
+  const auto json4 = formats::json::FromString(R"({"field":[[], []]})");
+  EXPECT_EQ((bool)formats::parse::TryParse(json,  formats::parse::To<SomeStruct6>{}), true);
+  EXPECT_EQ((bool)formats::parse::TryParse(json2, formats::parse::To<SomeStruct6>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json3, formats::parse::To<SomeStruct6>{}), false);
+  EXPECT_EQ((bool)formats::parse::TryParse(json4, formats::parse::To<SomeStruct6>{}), false);
+};
+
+struct SomeStruct7  {
+  int value;
+  std::vector<SomeStruct7> children = {};
+  inline constexpr bool operator==(const SomeStruct7& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct7> =
+    SerializationConfig<SomeStruct7>();
+
+
+TEST(Parse, Recursive) {
+  SomeStruct7 valid{.value = 1, .children = {{.value = 2}}};
+  const auto json = formats::json::FromString(R"({"value":1,"children":[{"value":2,"children":[]}]})");
+  const auto fromJson = json.As<SomeStruct7>();
+  EXPECT_EQ(fromJson, valid);
+};
+
+struct SomeStruct8 {
+  std::optional<int> field1;
+  inline bool operator==(const SomeStruct8& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct8> =
+  SerializationConfig<SomeStruct8>()
+  .With<"field1">({.Nullable = true});
+
+struct SomeStruct9 {
+  std::optional<int> field1;
+  inline bool operator==(const SomeStruct9& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct9> =
+  SerializationConfig<SomeStruct9>();
+
+
+TEST(Parse, Nullable) {
+  EXPECT_EQ(formats::json::FromString(R"({"field1":null})").As<SomeStruct8>(),
+      SomeStruct8{.field1 = std::nullopt});
+  EXPECT_THROW(formats::json::FromString(R"({"field1":null})").As<SomeStruct9>(),
+      formats::json::TypeMismatchException);
+}
+
+TEST(TryParse, Nullable) {
+  EXPECT_EQ(formats::parse::TryParse(formats::json::FromString(R"({"field1":null})"), formats::parse::To<SomeStruct8>{}),
+      SomeStruct8{.field1 = std::nullopt});
+  EXPECT_EQ(formats::parse::TryParse(formats::json::FromString(R"({"field1":null})"), formats::parse::To<SomeStruct9>{}),
+      std::nullopt);
+}
+
+struct SomeStruct10 {
+  std::unordered_map<std::string, int> map;
+  inline bool operator==(const SomeStruct10& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct10> =
+  SerializationConfig<SomeStruct10>();
+
+TEST(Parse, Map) {
+  const auto json = formats::json::FromString(R"({"map":{"1":1,"2":2}})");
+  SomeStruct10 valid;
+  valid.map.emplace("1", 1);
+  valid.map.emplace("2", 2);
+  EXPECT_EQ(json.As<SomeStruct10>(), valid);
+}
+TEST(Serialize, Map) {
+  const auto valid = formats::json::FromString(R"({"map":{"1":1,"2":2}})");
+  SomeStruct10 value;
+  value.map.emplace("1", 1);
+  value.map.emplace("2", 2);
+  const auto json = formats::json::ValueBuilder(value).ExtractValue();
+  EXPECT_EQ(json, valid);
+}
+
+struct SomeStruct11 {
+  int field;
+  inline constexpr bool operator==(const SomeStruct11& other) const = default;
+};
+template <typename Value>
+auto Parse(Value&& value, formats::parse::To<SomeStruct11>) -> SomeStruct11 {
+  return {.field = value["field"].template As<int>()};
+}
+
+template <typename Value>
+auto Serialize(const SomeStruct11& data, formats::serialize::To<Value>) {
+  typename Value::Builder builder;
+  builder["field"] = data.field;
+  return builder.ExtractValue();
+}
+
+struct SomeStruct12 {
+  SomeStruct11 field;
+  inline constexpr bool operator==(const SomeStruct12& other) const = default;
+};
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct12> =
+  SerializationConfig<SomeStruct12>();
+
+TEST(Serialize, NonUniversalInUniversal) {
+  const auto valid = formats::json::FromString(R"({"field":{"field":1}})");
+  const auto json = formats::json::ValueBuilder(SomeStruct12{.field = {.field = 1}}).ExtractValue();
+  EXPECT_EQ(json, valid);
+}
+
+TEST(Parse, NonUniversalInUniversal) {
+  const auto json = formats::json::FromString(R"({"field":{"field":1}})");
+  const SomeStruct12 valid{.field = {.field = 1}};
+  EXPECT_EQ(json.As<SomeStruct12>(), valid);
+}
+
+struct SomeStruct13 {
+  std::optional<std::vector<SomeStruct11>> field;
+  inline bool operator==(const SomeStruct13&) const = default;
+};
+
+
+template <>
+inline constexpr auto formats::universal::kSerialization<SomeStruct13> =
+  SerializationConfig<SomeStruct13>()
+  .With<"field">({.Default = []() -> std::vector<SomeStruct11> {
+    return {{.field = 1}};
+  }});
+
+TEST(Parse, NonLiteralDefaultTest) {
+  const auto json = formats::json::FromString(R"({})");
+  const SomeStruct13 valid{.field{std::vector<SomeStruct11>{{.field = 1}}}};
+  EXPECT_EQ(json.As<SomeStruct13>(), valid);
+}
+
+enum class SomeEnum {
+   kFoo, kBar
+};
+
+template <>
+inline constexpr utils::TrivialBiMap formats::enums::kEnumMapping<SomeEnum> = [](auto selector) {
+  return selector()
+    .Case(SomeEnum::kFoo, "foo")
+    .Case(SomeEnum::kBar, "bar");
+};
+
+TEST(Parse, Enum) {
+  const auto json = formats::json::FromString(R"("foo")");
+  EXPECT_EQ(json.As<SomeEnum>(), SomeEnum::kFoo);
+  EXPECT_EQ(formats::parse::ParseFromString<SomeEnum>("foo"), SomeEnum::kFoo);
+  const auto json2 = formats::json::FromString(R"("bar")");
+  EXPECT_EQ(json2.As<SomeEnum>(), SomeEnum::kBar);
+  EXPECT_EQ(formats::parse::ParseFromString<SomeEnum>("bar"), SomeEnum::kBar);
+}
+
+TEST(Serialize, Enum) {
+  const auto valid = formats::json::FromString(R"("foo")");
+  const auto json = formats::json::ValueBuilder(SomeEnum::kFoo).ExtractValue();
+  EXPECT_EQ(json, valid);
+  EXPECT_EQ(formats::serialize::ToString(SomeEnum::kFoo), "foo");
+  const auto valid2 = formats::json::FromString(R"("bar")");
+  const auto json2 = formats::json::ValueBuilder(SomeEnum::kBar).ExtractValue();
+  EXPECT_EQ(json2, valid2);
+  EXPECT_EQ(formats::serialize::ToString(SomeEnum::kBar), "bar");
+}
+
+
+USERVER_NAMESPACE_END
+#endif