diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..53878a7a
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,16 @@
+{
+    // Используйте IntelliSense, чтобы узнать о возможных атрибутах.
+    // Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов.
+    // Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug",
+            "program": "${workspaceFolder}/<executable file>",
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/openapi/base/array_property.hpp b/src/openapi/base/array_property.hpp
new file mode 100644
index 00000000..0500400a
--- /dev/null
+++ b/src/openapi/base/array_property.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include "property_base.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <typename T, typename Traits = EmptyTraits>
+struct ArrayProperty : public PropertyBase<std::vector<T>, Traits>
+{
+};
+
+template <typename T, typename Traits>
+struct Property<std::vector<T>, Traits> : public ArrayProperty<T, Traits>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/array_traits.hpp b/src/openapi/base/array_traits.hpp
new file mode 100644
index 00000000..edb0aaac
--- /dev/null
+++ b/src/openapi/base/array_traits.hpp
@@ -0,0 +1,121 @@
+#pragma once
+
+#include "array_property.hpp"
+#include "named_traits.hpp"
+#include "preferences.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+namespace timetable_vsu_backend::openapi
+{
+namespace checks
+{
+template <typename T>
+concept HasMin = requires
+{
+    {
+        T::kMin
+    }
+    ->std::convertible_to<utils::ConstexprOptional<size_t>>;
+};
+
+template <typename T>
+concept HasMax = requires
+{
+    {
+        T::kMax
+    }
+    ->std::convertible_to<utils::ConstexprOptional<size_t>>;
+};
+
+template <typename T>
+concept HasUniqueItems = requires
+{
+    {
+        T::kUniqueItems
+    }
+    ->std::convertible_to<utils::ConstexprOptional<bool>>;
+};
+
+template <typename T>
+concept HasNotMin = !HasMin<T>;
+
+template <typename T>
+concept HasNotMax = !HasMax<T>;
+
+template <typename T>
+concept HasNotUniqueItems = !HasUniqueItems<T>;
+}  // namespace checks
+
+namespace detail
+{
+template <checks::HasMin T>
+constexpr auto _getMin()
+{
+    return T::kMin;
+}
+
+template <checks::HasNotMin T>
+constexpr auto _getMin()
+{
+    return utils::ConstexprOptional<size_t>{utils::kNull};
+}
+
+template <checks::HasMax T>
+constexpr auto _getMax()
+{
+    return T::kMax;
+}
+
+template <checks::HasNotMax T>
+constexpr auto _getMax()
+{
+    return utils::ConstexprOptional<size_t>{utils::kNull};
+}
+
+template <checks::HasUniqueItems T>
+constexpr auto _getUniqueItems()
+{
+    return T::kUniqueItems;
+}
+
+template <checks::HasNotUniqueItems T>
+constexpr auto _getUniqueItems()
+{
+    return utils::ConstexprOptional<bool>{utils::kNull};
+}
+}  // namespace detail
+
+namespace traits
+{
+template <typename T>
+constexpr utils::ConstexprOptional<size_t> GetMin()
+{
+    return detail::_getMin<T>();
+}
+template <typename T>
+constexpr utils::ConstexprOptional<size_t> GetMax()
+{
+    return detail::_getMax<T>();
+}
+template <typename T>
+constexpr utils::ConstexprOptional<bool> GetUniqueItems()
+{
+    return detail::_getUniqueItems<T>();
+}
+
+template <typename Traits>
+struct ArrayHelperTraits : NamedHelperTraits<Traits>
+{
+    static constexpr utils::ConstexprOptional<size_t> min =
+        traits::GetMin<Traits>();
+    static constexpr utils::ConstexprOptional<size_t> max =
+        traits::GetMax<Traits>();
+    static constexpr utils::ConstexprOptional<bool> unique_items =
+        traits::GetUniqueItems<Traits>();
+    constexpr ArrayHelperTraits()
+    {
+    }
+};
+
+}  // namespace traits
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/extended_object_property.hpp b/src/openapi/base/extended_object_property.hpp
new file mode 100644
index 00000000..d065ebe8
--- /dev/null
+++ b/src/openapi/base/extended_object_property.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include "property_base.hpp"
+#include "userver/formats/json/value.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <checks::IsReflective T, typename Traits = EmptyTraits>
+struct ExtendedObjectProperty : public PropertyBase<T, Traits>
+{
+    userver::formats::json::Value additional_properties{};
+    const userver::formats::json::Value& GetAdditionalProperties()
+    {
+        return additional_properties;
+    }
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/named_traits.hpp b/src/openapi/base/named_traits.hpp
new file mode 100644
index 00000000..6973c832
--- /dev/null
+++ b/src/openapi/base/named_traits.hpp
@@ -0,0 +1,78 @@
+#pragma once
+#include <concepts>
+#include <type_traits>
+
+#include "property_base.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <utils::ConstexprString Name>
+struct NamedTraits
+{
+    static constexpr auto kName = Name;
+};
+
+namespace checks
+{
+template <typename T>
+concept HasName = requires
+{
+    {
+        decltype(T::kName)::kSize
+    }
+    ->std::convertible_to<std::size_t>;
+    requires std::is_same_v<utils::ConstexprString<decltype(T::kName)::kSize>,
+                            std::remove_cv_t<decltype(T::kName)>>;
+    {
+        T::kName
+    }
+    ->std::convertible_to<utils::ConstexprString<decltype(T::kName)::kSize>>;
+};
+
+template <typename T>
+concept HasNotName = !HasName<T>;
+}  // namespace checks
+
+namespace details
+{
+template <checks::HasName T>
+constexpr auto _getName()
+{
+    return T::kName;
+}
+
+template <checks::HasNotName T>
+constexpr auto _getName()
+{
+    using Type = utils::ConstexprString<1>;
+    return Type{""};
+}
+}  // namespace details
+
+
+struct ConstexprSetString{
+    std::array<std::string_view, 256> test;
+};
+
+consteval ConstexprSetString foo (){
+    return {};
+}
+
+namespace traits
+{
+// returns ConstexprOptional<ConstexprString>
+template <typename T>
+constexpr auto GetName()
+{
+    return details::_getName<T>();
+}
+
+template <typename Traits>
+struct NamedHelperTraits
+{
+    static constexpr auto name = traits::GetName<Traits>();
+};
+}  // namespace traits
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/object_field_names.hpp b/src/openapi/base/object_field_names.hpp
new file mode 100644
index 00000000..6f70f09b
--- /dev/null
+++ b/src/openapi/base/object_field_names.hpp
@@ -0,0 +1 @@
+#pragma once
diff --git a/src/openapi/base/object_property.hpp b/src/openapi/base/object_property.hpp
new file mode 100644
index 00000000..50e91c23
--- /dev/null
+++ b/src/openapi/base/object_property.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include "property_base.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <checks::IsReflective T, typename Traits = EmptyTraits>
+struct ObjectProperty : public PropertyBase<T, Traits>
+{
+};
+
+template <checks::IsReflective T, typename Traits>
+struct Property<T, Traits> : public ObjectProperty<T, Traits>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/object_traits.hpp b/src/openapi/base/object_traits.hpp
new file mode 100644
index 00000000..7dd90125
--- /dev/null
+++ b/src/openapi/base/object_traits.hpp
@@ -0,0 +1,92 @@
+#pragma once
+
+#include "extended_object_property.hpp"
+#include "named_traits.hpp"
+#include "object_property.hpp"
+#include "preferences.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+namespace timetable_vsu_backend::openapi
+{
+namespace checks
+{
+template <typename T>
+concept HasAdditionalProperties = requires
+{
+    {
+        T::kAdditionalProperties
+    }
+    ->std::convertible_to<utils::ConstexprOptional<bool>>;
+};
+
+template <typename T>
+concept HasUseRoot = requires
+{
+    {
+        T::kUseRoot
+    }
+    ->std::convertible_to<utils::ConstexprOptional<bool>>;
+};
+
+}  // namespace checks
+
+namespace detail
+{
+template <typename T>
+requires checks::HasAdditionalProperties<T> constexpr utils::ConstexprOptional<
+    bool>
+_getAdditionalProperties()
+{
+    return T::kAdditionalProperties;
+}
+
+template <typename T>
+requires(!checks::HasAdditionalProperties<
+         T>) constexpr utils::ConstexprOptional<bool> _getAdditionalProperties()
+{
+    return utils::kNull;
+}
+
+template <typename T>
+requires checks::HasUseRoot<T> constexpr utils::ConstexprOptional<bool>
+_getUseRoot()
+{
+    return T::kUseRoot;
+}
+
+template <typename T>
+requires(!checks::HasUseRoot<T>) constexpr utils::ConstexprOptional<
+    bool> _getUseRoot()
+{
+    return utils::kNull;
+}
+
+}  // namespace detail
+
+namespace traits
+{
+template <typename T>
+constexpr utils::ConstexprOptional<bool> GetAdditionalProperties()
+{
+    return detail::_getAdditionalProperties<T>();
+}
+template <typename T>
+constexpr utils::ConstexprOptional<bool> GetUseRoot()
+{
+    return detail::_getUseRoot<T>();
+}
+
+template <typename Traits>
+struct ObjectHelperTraits : NamedHelperTraits<Traits>
+{
+    static constexpr utils::ConstexprOptional<bool> use_root =
+        traits::GetUseRoot<Traits>();
+    static constexpr utils::ConstexprOptional<bool> additional_properties =
+        traits::GetAdditionalProperties<Traits>();
+    constexpr ObjectHelperTraits()
+    {
+    }
+};
+
+}  // namespace traits
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/optional_property.hpp b/src/openapi/base/optional_property.hpp
new file mode 100644
index 00000000..124148c7
--- /dev/null
+++ b/src/openapi/base/optional_property.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include "property_base.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <typename T, typename Traits = EmptyTraits>
+struct OptionalProperty : public PropertyBase<std::optional<T>, Traits>
+{
+};
+
+template <typename T, typename Traits>
+struct Property<std::optional<T>, Traits> : public OptionalProperty<T, Traits>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/preferences.hpp b/src/openapi/base/preferences.hpp
new file mode 100644
index 00000000..6c4064f2
--- /dev/null
+++ b/src/openapi/base/preferences.hpp
@@ -0,0 +1,47 @@
+#pragma once
+#include "utils/constexpr_string.hpp"
+
+namespace timetable_vsu_backend::openapi::preferences
+{
+template <auto value>
+struct value_holder
+{
+    static auto constexpr kValue = value;
+};
+
+template <size_t value>
+struct Min : value_holder<value>
+{
+};
+
+template <size_t value>
+struct Max : value_holder<value>
+{
+};
+
+template <bool value>
+struct UniqueItems : value_holder<value>
+{
+};
+
+template <utils::ConstexprString value>
+struct Name : value_holder<value>
+{
+};
+
+template <utils::ConstexprString value>
+struct Pattern : value_holder<value>
+{
+};
+
+template <bool value>
+struct AdditionalProperties : value_holder<value>
+{
+};
+
+template <bool value>
+struct UseRoot : value_holder<value>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi::preferences
diff --git a/src/openapi/base/property_base.hpp b/src/openapi/base/property_base.hpp
new file mode 100644
index 00000000..710f9eb2
--- /dev/null
+++ b/src/openapi/base/property_base.hpp
@@ -0,0 +1,56 @@
+#pragma once
+#include <concepts>
+#include <optional>
+#include <type_traits>
+#include <utility>
+
+namespace timetable_vsu_backend::openapi
+{
+struct EmptyTraits
+{
+};
+
+struct Yes
+{
+};
+
+namespace checks
+{
+template <typename T>
+concept IsReflective = requires
+{
+    requires std::is_class_v<T>;
+    typename T::Reflective;
+    requires std::same_as<typename T::Reflective, Yes>;
+};
+};  // namespace checks
+
+template <typename T, typename Traits = EmptyTraits>
+struct PropertyBase
+{
+    using value_type = T;
+    using traits = Traits;
+
+    template <class Arg>
+    value_type& operator=(Arg&& arg)
+    {
+        value = std::forward<Arg>(arg);
+        return value;
+    }
+    value_type& operator()()
+    {
+        return value;
+    }
+    const value_type& operator()() const
+    {
+        return value;
+    }
+    value_type value;
+};
+
+template <typename T, typename Traits = EmptyTraits>
+struct Property
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/reflective_property.hpp b/src/openapi/base/reflective_property.hpp
new file mode 100644
index 00000000..50e1afeb
--- /dev/null
+++ b/src/openapi/base/reflective_property.hpp
@@ -0,0 +1,38 @@
+#pragma once
+#include <type_traits>
+
+#include "property_base.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <typename T>
+concept IsReflective = requires
+{
+    requires std::is_class_v<T>;
+    typename T::Enable;
+    requires std::is_same_v<typename T::Enable, Yes>;
+};
+
+template <IsReflective T, typename Traits = EmptyTraits>
+struct ReflectiveProperty : public PropertyBase<T, Traits>
+{
+};
+
+template <IsReflective T, typename Traits>
+struct Property<T, Traits> : public ReflectiveProperty<T, Traits>
+{
+};
+
+template <IsReflective T, typename Traits = EmptyTraits>
+struct OptionalReflectiveProperty
+    : public PropertyBase<std::optional<T>, Traits>
+{
+};
+
+template <IsReflective T, typename Traits>
+struct Property<std::optional<T>, Traits>
+    : public OptionalReflectiveProperty<T, Traits>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/string_property.hpp b/src/openapi/base/string_property.hpp
new file mode 100644
index 00000000..9ba1af15
--- /dev/null
+++ b/src/openapi/base/string_property.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+#include "property_base.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+template <typename Traits = EmptyTraits>
+struct StringProperty : public PropertyBase<std::string, Traits>
+{
+};
+
+template <typename Traits>
+struct Property<std::string, Traits> : public StringProperty<Traits>
+{
+};
+
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/base/string_traits.hpp b/src/openapi/base/string_traits.hpp
new file mode 100644
index 00000000..f9a84ed7
--- /dev/null
+++ b/src/openapi/base/string_traits.hpp
@@ -0,0 +1,68 @@
+#pragma once
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+#include "array_property.hpp"
+#include "named_traits.hpp"
+#include "preferences.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+namespace timetable_vsu_backend::openapi
+{
+namespace checks
+{
+template <typename T>
+concept HasPattern = requires
+{
+    {
+        decltype(T::kPattern)::kSize
+    }
+    ->std::convertible_to<std::size_t>;
+    requires std::is_same_v<
+        utils::ConstexprString<decltype(T::kPattern)::kSize>,
+        std::remove_cv_t<decltype(T::kPattern)>>;
+    {
+        T::kPattern
+    }
+    ->std::convertible_to<utils::ConstexprString<decltype(T::kPattern)::kSize>>;
+};
+}  // namespace checks
+
+namespace detail
+{
+template <typename T>
+requires checks::HasPattern<T> constexpr auto _getPattern()
+{
+    return T::kPattern;
+}
+
+template <typename T>
+requires(!checks::HasPattern<T>) constexpr auto _getPattern()
+{
+    using Type = utils::ConstexprString<1>;
+    return Type{""};
+}
+}  // namespace detail
+
+namespace traits
+{
+template <typename T>
+constexpr auto GetPattern()
+{
+    return detail::_getPattern<T>();
+}
+
+template <typename Traits>
+struct StringHelperTraits
+{
+    static constexpr utils::ConstexprString name = traits::GetName<Traits>();
+    static constexpr utils::ConstexprString pattern =
+        traits::GetPattern<Traits>();
+    constexpr StringHelperTraits()
+    {
+    }
+};
+
+}  // namespace traits
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/json/parse/array_property.hpp b/src/openapi/json/parse/array_property.hpp
new file mode 100644
index 00000000..f0f38762
--- /dev/null
+++ b/src/openapi/json/parse/array_property.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <stdexcept>
+#include <unordered_map>
+
+#include "openapi/base/array_property.hpp"
+#include "openapi/base/array_traits.hpp"
+#include "openapi/base/named_traits.hpp"
+#include "userver/formats/json/value.hpp"
+#include "userver/formats/parse/to.hpp"
+#include "userver/logging/log.hpp"
+#include "utils/constexpr_string.hpp"
+
+namespace userver::formats::parse
+{
+template <typename T, typename Traits>
+timetable_vsu_backend::openapi::ArrayProperty<T, Traits> Parse(
+    const json::Value& item,
+    To<timetable_vsu_backend::openapi::ArrayProperty<T, Traits>>)
+{
+    using namespace timetable_vsu_backend::openapi;
+
+    constexpr traits::ArrayHelperTraits<Traits> traits;
+
+    std::vector<T> result = item.As<std::vector<T>>();
+
+    if constexpr (traits.min.HasValue())
+    {
+        if (result.size() < traits.min.value())
+        {
+            throw std::runtime_error(
+                fmt::format("Field has elements less than "
+                            "allowed, current: {}, min: {}",
+                            result.size(), traits.min.value()));
+        }
+    }
+    if constexpr (traits.max.HasValue())
+    {
+        if (result.size() > traits.max.value())
+        {
+            throw std::runtime_error(
+                fmt::format("Field has elements more than "
+                            "allowed, current: {}, max: {}",
+                            result.size(), traits.max.value()));
+        }
+    }
+    if constexpr (traits.unique_items.value_or(false))
+    {
+        std::unordered_map<T, size_t> map;
+        size_t index = 0;
+        for (auto& elem : result)
+        {
+            auto [it, inserted] = map.try_emplace(elem, index);
+            if (!inserted)
+            {
+                throw std::runtime_error(
+                    fmt::format("Field has equals elements, "
+                                "element {} and {} are equal",
+                                it->second + 1, index + 1));
+            }
+            index++;
+        }
+    }
+    return {std::move(result)};
+}
+
+}  // namespace userver::formats::parse
diff --git a/src/openapi/json/parse/object_property.hpp b/src/openapi/json/parse/object_property.hpp
new file mode 100644
index 00000000..de0e2d01
--- /dev/null
+++ b/src/openapi/json/parse/object_property.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <array>
+#include <stdexcept>
+#include <string_view>
+#include <unordered_map>
+#include <userver/utils/overloaded.hpp>
+
+#include "boost/pfr.hpp"
+#include "boost/pfr/core.hpp"
+#include "openapi/base/extended_object_property.hpp"
+#include "openapi/base/named_traits.hpp"
+#include "openapi/base/object_property.hpp"
+#include "openapi/base/object_traits.hpp"
+#include "userver/formats/json/value.hpp"
+#include "userver/formats/parse/to.hpp"
+#include "userver/logging/log.hpp"
+#include "utils/constexpr_string.hpp"
+
+namespace userver::formats::parse
+{
+template <typename T, typename Traits>
+timetable_vsu_backend::openapi::ObjectProperty<T, Traits> Parse(
+    const json::Value& item,
+    To<timetable_vsu_backend::openapi::ObjectProperty<T, Traits>>)
+{
+    using namespace timetable_vsu_backend::openapi;
+
+
+
+    // constexpr traits::ObjectHelperTraits<Traits> traits;
+    T result;
+    auto matcher_common_type = [&item]<typename F>(F& field) {
+        constexpr auto name = timetable_vsu_backend::openapi::traits::GetName<
+            typename F::traits>();
+        static_assert(!name.empty(), "Common field must have name");
+        field = item[name.AsStringView()].template As<F>();
+    };
+    auto matcher_object = [&item]<typename F, typename FTraits>(
+                              ObjectProperty<F, FTraits>& field) {
+        using R = ObjectProperty<F, FTraits>;
+        if constexpr (traits::GetUseRoot<FTraits>().value_or(false))
+        {
+            field = item.As<R>();
+        }
+        else
+        {
+            constexpr auto name =
+                timetable_vsu_backend::openapi::traits::GetName<FTraits>();
+            static_assert(!name.empty(),
+                          "Object field without use_root must have name");
+            field = item[name.AsStringView()].template As<R>();
+        }
+    };
+    auto matcher_extended_object =
+        [&item]<typename F, typename FTraits>(
+            ExtendedObjectProperty<F, FTraits>& field) {
+            using R = ExtendedObjectProperty<F, FTraits>;
+            if constexpr (traits::GetUseRoot<FTraits>().value_or(false))
+            {
+                field = item.As<R>();
+            }
+            else
+            {
+                constexpr auto name =
+                    timetable_vsu_backend::openapi::traits::GetName<FTraits>();
+                static_assert(!name.empty(),
+                              "Object field without use_root must have name");
+                field = item[name.AsStringView()].template As<R>();
+            }
+        };
+    auto matcher = utils::Overloaded{std::move(matcher_common_type),
+                                     std::move(matcher_object),
+                                     std::move(matcher_extended_object)};
+
+    boost::pfr::for_each_field(result, matcher);
+
+    return {std::move(result)};
+}
+
+}  // namespace userver::formats::parse
diff --git a/src/openapi/json/parse/string_property.hpp b/src/openapi/json/parse/string_property.hpp
new file mode 100644
index 00000000..05aa5e97
--- /dev/null
+++ b/src/openapi/json/parse/string_property.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <regex>
+#include <stdexcept>
+#include <string_view>
+#include <unordered_map>
+
+#include "openapi/base/named_traits.hpp"
+#include "openapi/base/string_property.hpp"
+#include "openapi/base/string_traits.hpp"
+#include "userver/formats/json/value.hpp"
+#include "userver/formats/parse/to.hpp"
+#include "userver/logging/log.hpp"
+#include "utils/constexpr_string.hpp"
+
+namespace userver::formats::parse
+{
+template <typename Traits>
+timetable_vsu_backend::openapi::StringProperty<Traits> Parse(
+    const json::Value& item,
+    To<timetable_vsu_backend::openapi::StringProperty<Traits>>)
+{
+    using namespace timetable_vsu_backend::openapi;
+
+    constexpr traits::StringHelperTraits<Traits> traits;
+
+    auto result = item.As<std::string>();
+
+    if constexpr (!traits.pattern.empty())
+    {
+        std::regex reg(traits.pattern.data());
+        if (!std::regex_match(result, reg))
+        {
+            throw std::runtime_error(
+                fmt::format("Field doesnt satisfy pattern: {}, value: {}",
+                            traits.pattern, result));
+        }
+    }
+    return {std::move(result)};
+}
+
+}  // namespace userver::formats::parse
diff --git a/src/openapi/types/array_type.hpp b/src/openapi/types/array_type.hpp
new file mode 100644
index 00000000..ec0f7540
--- /dev/null
+++ b/src/openapi/types/array_type.hpp
@@ -0,0 +1,123 @@
+#pragma once
+#include <string_view>
+
+#include "openapi/base/array_traits.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+namespace detail
+{
+template <utils::ConstexprString Name,
+          utils::ConstexprOptional<size_t> Min = utils::kNull,
+          utils::ConstexprOptional<size_t> Max = utils::kNull,
+          utils::ConstexprOptional<bool> UniqueItems = utils::kNull>
+struct ArrayTraits : NamedTraits<Name>
+{
+    static constexpr auto kMin = Min;
+    static constexpr auto kMax = Max;
+    static constexpr auto kUniqueItems = UniqueItems;
+};
+
+//вся эта структура нужна для того, чтобы работать с трейтами как с значением и
+//применять поэтапно опции
+//у меня нет иного выбора, кроме как стереть информацию о
+//реальном размере строки, так как мне нельзя менять тип.
+// 256 должно хватить
+struct ArrayTraitsHolder
+{
+    std::array<char, 256> Name{};
+    size_t Name_was_changed = 0;
+    utils::ConstexprOptional<size_t> Min = utils::kNull;
+    size_t Min_was_changed = 0;
+    utils::ConstexprOptional<size_t> Max = utils::kNull;
+    size_t Max_was_changed = 0;
+    utils::ConstexprOptional<bool> UniqueItems = utils::kNull;
+    size_t UniqueItems_was_changed = 0;
+};
+
+template <utils::ConstexprString value>
+void consteval Apply(ArrayTraitsHolder& traits, preferences::Name<value> name)
+{
+    size_t Size = name.kValue.kSize;
+    for (size_t index = 0; index < Size; index++)
+    {
+        traits.Name[index] = name.kValue[index];
+    }
+    for (size_t index = Size; index < 256; index++)
+    {
+        traits.Name[index] = '\0';
+    }
+    traits.Name_was_changed++;
+}
+
+template <typename T>
+void consteval Apply(ArrayTraitsHolder&, const T&)
+{
+    static_assert(
+        ![] {}, "You are used unknown option");
+}
+
+template <size_t value>
+void consteval Apply(ArrayTraitsHolder& traits, preferences::Min<value>)
+{
+    traits.Min = value;
+    traits.Min_was_changed++;
+}
+
+template <size_t value>
+void consteval Apply(ArrayTraitsHolder& traits, preferences::Max<value>)
+{
+    traits.Max = value;
+    traits.Max_was_changed++;
+}
+
+template <bool value>
+void consteval Apply(ArrayTraitsHolder& traits, preferences::UniqueItems<value>)
+{
+    traits.UniqueItems = value;
+    traits.UniqueItems_was_changed++;
+}
+
+template <typename... Option>
+void consteval ApplyAll(ArrayTraitsHolder& traits, Option... option)
+{
+    (Apply(traits, option), ...);
+}
+
+template <typename T, typename... Option>
+struct ArrayMagicHelper
+{
+    consteval static auto resolve_holder()
+    {
+        ArrayTraitsHolder helper{};
+        ApplyAll(helper, Option{}...);
+        return helper;
+    }
+    consteval static auto resolve_traits()
+    {
+        constexpr ArrayTraitsHolder traits = resolve_holder();
+        constexpr auto name = utils::MakeConstexprString<traits.Name>();
+        static_assert(traits.Name_was_changed <= 1,
+                      "Don't use more 1 Name in template args");
+        static_assert(traits.Max_was_changed <= 1,
+                      "Don't use more 1 Max in template args");
+        static_assert(traits.Min_was_changed <= 1,
+                      "Don't use more 1 Min in template args");
+        static_assert(traits.UniqueItems_was_changed <= 1,
+                      "Don't use more 1 UniqueItems in template args");
+        return ArrayTraits<name, traits.Min, traits.Max, traits.UniqueItems>{};
+    }
+};
+
+template <typename T, typename... Option>
+using array_traits_helper_t =
+    decltype(ArrayMagicHelper<T, Option...>::resolve_traits());
+}  // namespace detail
+
+namespace types
+{
+template <typename T, typename... Option>
+using Array = ArrayProperty<T, detail::array_traits_helper_t<T, Option...>>;
+
+}
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/types/object_type.hpp b/src/openapi/types/object_type.hpp
new file mode 100644
index 00000000..43ab3a27
--- /dev/null
+++ b/src/openapi/types/object_type.hpp
@@ -0,0 +1,126 @@
+#pragma once
+#include <string_view>
+
+#include "openapi/base/extended_object_property.hpp"
+#include "openapi/base/object_property.hpp"
+#include "openapi/base/preferences.hpp"
+#include "openapi/base/string_property.hpp"
+#include "openapi/base/string_traits.hpp"
+#include "utils/constexpr_optional.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+namespace detail
+{
+template <utils::ConstexprString Name, utils::ConstexprOptional<bool> UseRoot,
+          utils::ConstexprOptional<bool> AdditionalProperties>
+struct ObjectTraits : NamedTraits<Name>
+{
+    static constexpr auto kUseRoot = UseRoot;
+    static constexpr auto kAdditionalProperties = AdditionalProperties;
+};
+
+//вся эта структура нужна для того, чтобы работать с трейтами как с значением и
+//применять поэтапно опции
+//у меня нет иного выбора, кроме как стереть информацию о
+//реальном размере строки, так как мне нельзя менять тип.
+// 256 должно хватить
+struct ObjectTraitsHolder
+{
+    utils::ConstexprOptional<bool> AdditionalProperties{utils::kNull};
+    size_t AdditionalProperties_was_changed = 0;
+    utils::ConstexprOptional<bool> UseRoot{utils::kNull};
+    size_t UseRoot_was_changed = 0;
+    std::array<char, 256> Name{};
+    size_t Name_was_changed = 0;
+};
+
+template <utils::ConstexprString value>
+void consteval Apply(ObjectTraitsHolder& traits, preferences::Name<value> name)
+{
+    size_t Size = name.kValue.kSize;
+    for (size_t index = 0; index < Size; index++)
+    {
+        traits.Name[index] = name.kValue[index];
+    }
+    for (size_t index = Size; index < 256; index++)
+    {
+        traits.Name[index] = '\0';
+    }
+    traits.Name_was_changed++;
+}
+
+template <bool value>
+void consteval Apply(ObjectTraitsHolder& traits, preferences::UseRoot<value>)
+{
+    traits.UseRoot = value;
+    traits.Name_was_changed++;
+}
+
+template <bool value>
+void consteval Apply(ObjectTraitsHolder& traits,
+                     preferences::AdditionalProperties<value>)
+{
+    traits.AdditionalProperties = value;
+    traits.AdditionalProperties_was_changed++;
+}
+
+template <typename T>
+void consteval Apply(ObjectTraitsHolder&, const T&)
+{
+    static_assert(
+        ![] {}, "You are used unknown option");
+}
+
+template <typename... Option>
+void consteval ApplyAll(ObjectTraitsHolder& traits, Option... option)
+{
+    (Apply(traits, option), ...);
+}
+
+template <typename T, typename... Option>
+struct ObjectMagicHelper
+{
+    consteval static auto resolve_holder()
+    {
+        ObjectTraitsHolder helper{};
+        ApplyAll(helper, Option{}...);
+        return helper;
+    }
+    consteval static auto resolve_traits()
+    {
+        constexpr ObjectTraitsHolder traits = resolve_holder();
+        constexpr auto name = utils::MakeConstexprString<traits.Name>();
+        static_assert(traits.Name_was_changed <= 1,
+                      "Don't use more 1 Name in template args");
+        static_assert(traits.UseRoot_was_changed <= 1,
+                      "Don't use more 1 UseRoot in template args");
+        static_assert(traits.AdditionalProperties_was_changed <= 1,
+                      "Don't use more 1 AdditionalProperties in template args");
+        return ObjectTraits<name, traits.UseRoot.value_or(false),
+                            traits.AdditionalProperties.value_or(false)>{};
+    }
+    consteval static auto resolve_type()
+    {
+        using Traits = decltype(resolve_traits());
+        if constexpr (Traits::kAdditionalProperties.value_or(false))
+        {
+            return ExtendedObjectProperty<T, Traits>{};
+        }
+        else
+        {
+            return ObjectProperty<T, Traits>{};
+        }
+    }
+};
+
+}  // namespace detail
+
+namespace types
+{
+template <typename T, typename... Option>
+using Object =
+    decltype(detail::ObjectMagicHelper<T, Option...>::resolve_type());
+
+}
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/openapi/types/string_type.hpp b/src/openapi/types/string_type.hpp
new file mode 100644
index 00000000..705d200c
--- /dev/null
+++ b/src/openapi/types/string_type.hpp
@@ -0,0 +1,108 @@
+#pragma once
+#include <string_view>
+
+#include "openapi/base/preferences.hpp"
+#include "openapi/base/string_property.hpp"
+#include "openapi/base/string_traits.hpp"
+
+namespace timetable_vsu_backend::openapi
+{
+namespace detail
+{
+template <utils::ConstexprString Name, utils::ConstexprString Pattern>
+struct StringTraits : NamedTraits<Name>
+{
+    static constexpr auto kPattern = Pattern;
+};
+
+//вся эта структура нужна для того, чтобы работать с трейтами как с значением и
+//применять поэтапно опции
+//у меня нет иного выбора, кроме как стереть информацию о
+//реальном размере строки, так как мне нельзя менять тип.
+// 256 должно хватить
+struct StringTraitsHolder
+{
+    std::array<char, 256> Pattern{};
+    size_t Pattern_was_changed = 0;
+    std::array<char, 256> Name{};
+    size_t Name_was_changed = 0;
+};
+
+template <utils::ConstexprString value>
+void consteval Apply(StringTraitsHolder& traits, preferences::Name<value> name)
+{
+    size_t Size = name.kValue.kSize;
+    for (size_t index = 0; index < Size; index++)
+    {
+        traits.Name[index] = name.kValue[index];
+    }
+    for (size_t index = Size; index < 256; index++)
+    {
+        traits.Name[index] = '\0';
+    }
+    traits.Name_was_changed++;
+}
+
+template <utils::ConstexprString value>
+void consteval Apply(StringTraitsHolder& traits,
+                     preferences::Pattern<value> name)
+{
+    size_t Size = name.kValue.kSize;
+    for (size_t index = 0; index < Size; index++)
+    {
+        traits.Pattern[index] = name.kValue[index];
+    }
+    for (size_t index = Size; index < 256; index++)
+    {
+        traits.Pattern[index] = '\0';
+    }
+    traits.Pattern_was_changed++;
+}
+
+template <typename T>
+void consteval Apply(StringTraitsHolder&, const T&)
+{
+    static_assert(
+        ![] {}, "You are used unknown option");
+}
+
+template <typename... Option>
+void consteval ApplyAll(StringTraitsHolder& traits, Option... option)
+{
+    (Apply(traits, option), ...);
+}
+
+template <typename... Option>
+struct StringMagicHelper
+{
+    consteval static auto resolve_holder()
+    {
+        StringTraitsHolder helper{};
+        ApplyAll(helper, Option{}...);
+        return helper;
+    }
+    consteval static auto resolve_traits()
+    {
+        constexpr StringTraitsHolder traits = resolve_holder();
+        constexpr auto name = utils::MakeConstexprString<traits.Name>();
+        constexpr auto pattern = utils::MakeConstexprString<traits.Pattern>();
+        static_assert(traits.Name_was_changed <= 1,
+                      "Don't use more 1 Name in template args");
+        static_assert(traits.Pattern_was_changed <= 1,
+                      "Don't use more 1 Pattern in template args");
+        return StringTraits<name, pattern>{};
+    }
+};
+
+template <typename... Option>
+using string_traits_helper_t =
+    decltype(StringMagicHelper<Option...>::resolve_traits());
+}  // namespace detail
+
+namespace types
+{
+template <typename... Option>
+using String = StringProperty<detail::string_traits_helper_t<Option...>>;
+
+}
+}  // namespace timetable_vsu_backend::openapi
diff --git a/src/utils/constexpr_optional.hpp b/src/utils/constexpr_optional.hpp
new file mode 100644
index 00000000..88670155
--- /dev/null
+++ b/src/utils/constexpr_optional.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <cstddef>
+#include <optional>
+#include <string_view>
+namespace timetable_vsu_backend::utils
+{
+struct AccessToNull : public std::exception
+{
+   public:
+    AccessToNull() = default;
+    virtual ~AccessToNull() = default;
+
+    const char* what() const noexcept override
+    {
+        return "Attempt access to Null";
+    }
+};
+
+struct Null
+{
+};
+
+static constexpr Null kNull = {};
+
+template <typename T>
+struct ConstexprOptional
+{
+    using value_type = T;
+    T value_;
+    bool has_value_;
+    constexpr ConstexprOptional(const T& value) noexcept
+        : value_(value), has_value_(true)
+    {
+    }
+    constexpr ConstexprOptional(Null) noexcept : value_{}, has_value_(false)
+    {
+    }
+    constexpr bool HasValue() const noexcept
+    {
+        return has_value_;
+    }
+    constexpr bool IsNull() const noexcept
+    {
+        return !HasValue();
+    }
+    constexpr const T& get_value() const
+    {
+        if (!IsNull())
+        {
+            throw AccessToNull();
+        }
+        return value_;
+    }
+    constexpr const T& value() const
+    {
+        if (IsNull())
+        {
+            throw AccessToNull();
+        }
+        return value_;
+    }
+    constexpr T& value()
+    {
+        if (IsNull())
+        {
+            throw AccessToNull();
+        }
+        return value_;
+    }
+    constexpr ConstexprOptional& operator=(const T& t) noexcept
+    {
+        value_ = t;
+        has_value_ = true;
+        return *this;
+    }
+    constexpr ConstexprOptional& operator=(Null) noexcept
+    {
+        has_value_ = false;
+        return *this;
+    }
+    constexpr const T& value_or(const T& t) const noexcept
+    {
+        if (IsNull())
+        {
+            return t;
+        }
+        else
+            return value();
+    }
+};
+
+}  // namespace timetable_vsu_backend::utils
diff --git a/utests/openapi/json/parse/basic_array.cpp b/utests/openapi/json/parse/basic_array.cpp
new file mode 100644
index 00000000..661782df
--- /dev/null
+++ b/utests/openapi/json/parse/basic_array.cpp
@@ -0,0 +1,108 @@
+#include <gtest/gtest.h>
+
+#include <exception>
+#include <string_view>
+#include <userver/utest/utest.hpp>
+#include <vector>
+
+#include "openapi/base/named_traits.hpp"
+#include "openapi/base/preferences.hpp"
+#include "openapi/json/parse/array_property.hpp"
+#include "openapi/types/array_type.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+#include "views/hello/view.hpp"
+
+using namespace timetable_vsu_backend::openapi;
+
+UTEST(Openapi_Json_Serialize, BasicArrayProperty)
+{
+    using Type = types::Array<int>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : [1,2,2]
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    auto item = json["test"].As<Type>();
+    std::vector<int> expected_item{1, 2, 2};
+    EXPECT_EQ(item(), expected_item);
+}
+
+UTEST(Openapi_Json_Serialize, BasicArrayPropertyMin)
+{
+    using Type = types::Array<int, preferences::Min<4>>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : [1,2,2]
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    bool was_exception = false;
+    try
+    {
+        json["test"].As<Type>();
+    }
+    catch (std::exception& exc)
+    {
+        was_exception = true;
+        std::string exc_msg = exc.what();
+        std::string expected =
+            "Field has elements less than allowed, current: 3, "
+            "min: 4";
+        EXPECT_EQ(exc_msg, expected);
+    }
+    EXPECT_TRUE(was_exception);
+}
+
+UTEST(Openapi_Json_Serialize, BasicArrayPropertyMax)
+{
+    using Type = types::Array<int, preferences::Min<1>, preferences::Max<2>>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : [1,2,2]
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    bool was_exception = false;
+    try
+    {
+        json["test"].As<Type>();
+    }
+    catch (std::exception& exc)
+    {
+        was_exception = true;
+        std::string exc_msg = exc.what();
+        std::string expected =
+            "Field has elements more than allowed, current: 3, "
+            "max: 2";
+        EXPECT_EQ(exc_msg, expected);
+    }
+    EXPECT_TRUE(was_exception);
+}
+
+UTEST(Openapi_Json_Serialize, BasicArrayPropertyUnique)
+{
+    using Type = types::Array<int, preferences::UniqueItems<true>>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : [1,2,2]
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    bool was_exception = false;
+    try
+    {
+        json["test"].As<Type>();
+    }
+    catch (std::exception& exc)
+    {
+        was_exception = true;
+        std::string exc_msg = exc.what();
+        std::string expected =
+            "Field has equals elements, element 2 and 3 are "
+            "equal";
+        EXPECT_EQ(exc_msg, expected);
+    }
+    EXPECT_TRUE(was_exception);
+}
diff --git a/utests/openapi/json/parse/basic_object.cpp b/utests/openapi/json/parse/basic_object.cpp
new file mode 100644
index 00000000..ebfbf38f
--- /dev/null
+++ b/utests/openapi/json/parse/basic_object.cpp
@@ -0,0 +1,86 @@
+#include <gtest/gtest.h>
+
+#include <exception>
+#include <string_view>
+#include <userver/utest/utest.hpp>
+#include <vector>
+
+#include "openapi/base/named_traits.hpp"
+#include "openapi/base/preferences.hpp"
+#include "openapi/base/property_base.hpp"
+#include "openapi/base/string_traits.hpp"
+#include "openapi/json/parse/array_property.hpp"
+#include "openapi/json/parse/object_property.hpp"
+#include "openapi/json/parse/string_property.hpp"
+#include "openapi/types/array_type.hpp"
+#include "openapi/types/object_type.hpp"
+#include "openapi/types/string_type.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+#include "views/hello/view.hpp"
+
+using namespace timetable_vsu_backend::openapi;
+using namespace timetable_vsu_backend::openapi::types;
+using namespace timetable_vsu_backend::openapi::preferences;
+
+struct First
+{
+    String<Name<"field">> field;
+    Array<int, Name<"field2">> field2;
+    using Reflective = Yes;
+};
+
+UTEST(Openapi_Json_Serialize, BasicObject)
+{
+    static_assert(checks::IsReflective<First>);
+    using Type = Object<First>;
+    constexpr auto jsonString = R"(
+        {
+            "field" : "test",
+            "field2" : [1,3,5]
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    auto got_object = json.As<Type>();
+    auto expected_object = Type();
+    expected_object().field() = "test";
+    expected_object().field2() = {1, 3, 5};
+    EXPECT_EQ(got_object().field(), expected_object().field());
+    EXPECT_EQ(got_object().field2(), expected_object().field2());
+}
+
+struct SecondRootObject
+{
+    String<Name<"field">> field;
+    Array<int, Name<"field2">> field2;
+    using Reflective = Yes;
+};
+
+struct SecondSubObject
+{
+    Object<SecondRootObject, UseRoot<true>> a;
+    String<Name<"field3">> field3;
+    using Reflective = Yes;
+};
+
+UTEST(Openapi_Json_Serialize, BasicUseRootObject)
+{
+    using Type = Object<SecondSubObject>;
+    constexpr auto jsonString = R"(
+        {
+            "field" : "test",
+            "field2" : [1,3,5],
+            "field3" : "test3"
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    auto got_object = json.As<Type>();
+    auto expected_object = Type();
+    expected_object().a().field() = "test";
+    expected_object().a().field2() = {1, 3, 5};
+    expected_object().field3() = "test3";
+    EXPECT_EQ(expected_object().a().field(), got_object().a().field());
+    EXPECT_EQ(expected_object().a().field2(),
+              got_object().a().field2());
+    EXPECT_EQ(expected_object().field3(), got_object().field3());
+}
diff --git a/utests/openapi/json/parse/basic_string.cpp b/utests/openapi/json/parse/basic_string.cpp
new file mode 100644
index 00000000..b419654e
--- /dev/null
+++ b/utests/openapi/json/parse/basic_string.cpp
@@ -0,0 +1,67 @@
+#include <gtest/gtest.h>
+
+#include <exception>
+#include <string_view>
+#include <userver/utest/utest.hpp>
+#include <vector>
+
+#include "openapi/base/named_traits.hpp"
+#include "openapi/base/preferences.hpp"
+#include "openapi/base/string_traits.hpp"
+#include "openapi/json/parse/string_property.hpp"
+#include "openapi/types/string_type.hpp"
+#include "utils/constexpr_optional.hpp"
+#include "utils/constexpr_string.hpp"
+#include "views/hello/view.hpp"
+
+using namespace timetable_vsu_backend::openapi;
+
+UTEST(Openapi_Json_Serialize, BasicStringPattern)
+{
+    using Type = types::String<preferences::Pattern<"dsds">>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : ""
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    bool was_exception = false;
+    try
+    {
+        json["test"].As<Type>();
+    }
+    catch (std::exception& exc)
+    {
+        was_exception = true;
+        std::string exc_msg = exc.what();
+        std::string expected = "Field doesnt satisfy pattern: dsds, value: ";
+        EXPECT_EQ(exc_msg, expected);
+    }
+    EXPECT_TRUE(was_exception);
+}
+
+UTEST(Openapi_Json_Serialize, EndStringPattern)
+{
+    using Type = types::String<preferences::Pattern<"some_text$">>;
+    constexpr auto jsonString = R"(
+        {
+            "test" : "some_text_not_end"
+        }
+    )";
+    auto json = userver::formats::json::FromString(jsonString);
+    bool was_exception = false;
+    try
+    {
+        json["test"].As<Type>();
+    }
+    catch (std::exception& exc)
+    {
+        was_exception = true;
+        std::string exc_msg = exc.what();
+        std::string expected =
+            "Field doesnt satisfy pattern: some_text$, value: "
+            "some_text_not_end";
+        EXPECT_EQ(exc_msg, expected);
+    }
+    EXPECT_TRUE(was_exception);
+}