couchbase 1.3.14 → 3.0.0.alpha.4

data/ext/third_party/json/include/tao/json/contrib/pointer_traits.hpp

@@ -0,0 +1,59 @@
+#ifndef TAO_JSON_CONTRIB_POINTER_TRAITS_HPP
+#define TAO_JSON_CONTRIB_POINTER_TRAITS_HPP
+
+#include "../pointer.hpp"
+#include "../traits.hpp"
+
+namespace tao::json
+{
+   struct token_traits
+   {
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const token& t )
+      {
+         if( t.has_index() ) {
+            v = t.index();
+         }
+         else {
+            v = t.key();
+         }
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const token& t )
+      {
+         if( t.has_index() ) {
+            json::events::produce< Traits >( c, t.index() );
+         }
+         else {
+            json::events::produce< Traits >( c, t.key() );
+         }
+      }
+   };
+
+   struct pointer_traits
+   {
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const pointer& p )
+      {
+         v.prepare_array().reserve( p.size() );
+         for( const auto& i : p ) {
+            v.emplace_back( i );
+         }
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const pointer& p )
+      {
+         c.begin_array( p.size() );
+         for( const auto& i : p ) {
+            json::events::produce< Traits >( c, i );
+            c.element();
+         }
+         c.end_array( p.size() );
+      }
+   };
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/position.hpp

@@ -0,0 +1,166 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_POSITION_HPP
+#define TAO_JSON_CONTRIB_POSITION_HPP
+
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "../events/to_value.hpp"
+#include "../events/transformer.hpp"
+#include "../from_file.hpp"
+#include "../message_extension.hpp"
+#include "../value.hpp"
+
+namespace tao::json
+{
+   struct position
+   {
+   private:
+      std::size_t m_line = 0;
+      std::size_t m_byte_in_line = 0;
+      std::string m_source;
+
+   public:
+      position() noexcept
+      {}
+
+      position( std::string in_source, const std::size_t in_line, const std::size_t in_byte_in_line )
+         : m_line( in_line ),
+           m_byte_in_line( in_byte_in_line ),
+           m_source( std::move( in_source ) )
+      {}
+
+      position( const position& ) = default;
+
+      position( position&& p ) noexcept
+      {
+         m_line = p.m_line;
+         m_byte_in_line = p.m_byte_in_line;
+         m_source = std::move( p.m_source );
+      }
+
+      ~position() = default;
+
+      position& operator=( const position& ) = default;
+
+      position& operator=( position&& p ) noexcept
+      {
+         m_line = p.m_line;
+         m_byte_in_line = p.m_byte_in_line;
+         m_source = std::move( p.m_source );
+         return *this;
+      }
+
+      [[nodiscard]] const std::string& source() const noexcept
+      {
+         return m_source;
+      }
+
+      [[nodiscard]] std::size_t line() const noexcept
+      {
+         return m_line;
+      }
+
+      [[nodiscard]] std::size_t byte_in_line() const noexcept
+      {
+         return m_byte_in_line;
+      }
+
+      void set_source( const std::string& s )
+      {
+         m_source = s;
+      }
+
+      template< typename T >
+      void set_position( const T& p )
+      {
+         m_line = p.line;
+         m_byte_in_line = p.byte_in_line;
+         m_source = p.source;
+      }
+
+      void append_message_extension( std::ostream& os ) const
+      {
+         os << '[' << m_source << ':' << m_line << ':' << m_byte_in_line << ']';
+      }
+   };
+
+   namespace internal
+   {
+      template< typename Rule >
+      struct position_action
+         : action< Rule >
+      {
+      };
+
+      template<>
+      struct position_action< rules::object::begin >
+      {
+         template< typename Input, typename Consumer >
+         static void apply( const Input& in, Consumer& consumer )
+         {
+            action< rules::object::begin >::apply0( consumer );
+            consumer.stack_.back().set_position( in.position() );
+         }
+      };
+
+      template<>
+      struct position_action< rules::array::begin >
+      {
+         template< typename Input, typename Consumer >
+         static void apply( const Input& in, Consumer& consumer )
+         {
+            action< rules::array::begin >::apply0( consumer );
+            consumer.stack_.back().set_position( in.position() );
+         }
+      };
+
+      template<>
+      struct position_action< rules::sor_value >
+      {
+         template< typename Input, typename Consumer >
+         static void apply( const Input& in, Consumer& consumer )
+         {
+            consumer.value.set_position( in.position() );
+         }
+      };
+
+      template< template< typename... > class Traits >
+      struct position_traits
+         : Traits< void >
+      {
+         template< typename >
+         using public_base = position;
+      };
+
+   }  // namespace internal
+
+   template< template< typename... > class Traits >
+   struct make_position_traits
+   {
+      template< typename T >
+      using type = std::conditional_t< std::is_same_v< T, void >, internal::position_traits< Traits >, Traits< T > >;
+   };
+
+   template< template< typename... > class Traits, template< typename... > class... Transformers >
+   [[nodiscard]] auto basic_from_file_with_position( const std::string& filename )
+   {
+      events::transformer< events::to_basic_value< Traits >, Transformers... > consumer;
+      pegtl::file_input< pegtl::tracking_mode::eager > in( filename );
+      pegtl::parse< internal::grammar, internal::position_action, internal::errors >( in, consumer );
+      return std::move( consumer.value );
+   }
+
+   template< template< typename... > class... Transformers >
+   [[nodiscard]] auto from_file_with_position( const std::string& filename )
+   {
+      return basic_from_file_with_position< make_position_traits< traits >::template type, Transformers... >( filename );
+   }
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/reference.hpp

@@ -0,0 +1,115 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_REFERENCE_HPP
+#define TAO_JSON_CONTRIB_REFERENCE_HPP
+
+#include "../internal/uri_fragment.hpp"
+#include "../pointer.hpp"
+#include "../value.hpp"
+
+namespace tao::json
+{
+   namespace internal
+   {
+      // JSON Reference, see draft ("work in progress") RFC at
+      // https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
+
+      // NOTE: Currently, only URI fragments are supported.
+      // Remote references are ignored, i.e., left untouched.
+
+      // JSON References are replaced with a VALUE_PTR,
+      // which might lead to infinite loops if you try
+      // to traverse the value. Make sure you understand
+      // the consequences and handle the resulting value
+      // accordingly!
+
+      // Self-references will throw an exception, as well as
+      // references into JSON Reference additional members
+      // (which shall be ignored as per the specification).
+
+      template< template< typename... > class Traits >
+      void resolve_references( basic_value< Traits >& r, basic_value< Traits >& v )
+      {
+         switch( v.type() ) {
+            case type::UNINITIALIZED:
+               return;
+            case type::NULL_:
+            case type::BOOLEAN:
+            case type::SIGNED:
+            case type::UNSIGNED:
+            case type::DOUBLE:
+            case type::STRING:
+            case type::STRING_VIEW:
+            case type::BINARY:
+            case type::BINARY_VIEW:
+               return;
+            case type::ARRAY:
+               for( auto& e : v.get_array() ) {
+                  resolve_references( r, e );
+               }
+               return;
+            case type::OBJECT:
+               for( auto& e : v.get_object() ) {
+                  resolve_references( r, e.second );
+               }
+               if( const auto* ref = v.find( "$ref" ) ) {
+                  ref = &ref->skip_value_ptr();
+                  if( ref->is_string_type() ) {
+                     const std::string_view s = ref->get_string_type();
+                     if( !s.empty() && s[ 0 ] == '#' ) {
+                        const pointer ptr = internal::uri_fragment_to_pointer( s );
+                        const auto* p = &r;
+                        auto it = ptr.begin();
+                        while( it != ptr.end() ) {
+                           switch( p->type() ) {
+                              case type::ARRAY:
+                                 p = &p->at( it->index() ).skip_value_ptr();
+                                 break;
+                              case type::OBJECT:
+                                 if( const auto* t = p->find( "$ref" ) ) {
+                                    if( t->is_string_type() ) {
+                                       throw std::runtime_error( "invalid JSON Reference: referencing additional data members is invalid" );
+                                    }
+                                 }
+                                 p = &p->at( it->key() ).skip_value_ptr();
+                                 break;
+                              default:
+                                 throw invalid_type( ptr.begin(), std::next( it ) );
+                           }
+                           ++it;
+                        }
+                        if( p == &v ) {
+                           throw std::runtime_error( "JSON Reference: invalid self reference" );
+                        }
+                        v.set_value_ptr( p );
+                        resolve_references( r, v );
+                     }
+                     else {
+                        // Ignore remote references for now...
+                        // throw std::runtime_error( "JSON Reference: unsupported or invalid URI: " + s ); // NOLINT
+                     }
+                  }
+               }
+               return;
+            case type::VALUE_PTR:
+               return;
+            case type::OPAQUE_PTR:
+               return;
+            case type::VALUELESS_BY_EXCEPTION:
+               return;
+         }
+         throw std::logic_error( "invalid value for tao::json::type" );  // LCOV_EXCL_LINE
+      }
+
+   }  // namespace internal
+
+   template< template< typename... > class Traits >
+   void resolve_references( basic_value< Traits >& r )
+   {
+      internal::resolve_references( r, r );
+   }
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/schema.hpp

@@ -0,0 +1,1851 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_SCHEMA_HPP
+#define TAO_JSON_CONTRIB_SCHEMA_HPP
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <regex>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+#include "reference.hpp"
+
+#include "../events/compare.hpp"
+#include "../events/from_value.hpp"
+#include "../events/hash.hpp"
+#include "../pointer.hpp"
+#include "../value.hpp"
+
+#include "../external/pegtl/contrib/uri.hpp"
+#include "../external/pegtl/parse.hpp"
+
+namespace tao::json
+{
+   namespace internal
+   {
+      // TODO: Check if these grammars are correct.
+      struct local_part_label
+         : pegtl::plus< pegtl::sor< pegtl::alnum, pegtl::one< '!', '#', '$', '%', '&', '\'', '*', '+', '-', '/', '=', '?', '^', '_', '`', '{', '|', '}', '~' > > >
+      {};
+
+      struct local_part
+         : pegtl::list_must< local_part_label, pegtl::one< '.' > >
+      {};
+
+      struct hostname_label
+         : pegtl::seq< pegtl::alnum, pegtl::rep_max< 62, pegtl::ranges< 'a', 'z', 'A', 'Z', '0', '9', '-' > > >
+      {};
+
+      struct hostname
+         : pegtl::list_must< hostname_label, pegtl::one< '.' > >
+      {};
+
+      struct email
+         : pegtl::seq< local_part, pegtl::one< '@' >, hostname >
+      {};
+
+      template< typename Rule >
+      [[nodiscard]] bool parse( const std::string_view v )
+      {
+         pegtl::memory_input in( v.data(), v.size(), "" );
+         return pegtl::parse< pegtl::seq< Rule, pegtl::eof > >( in );
+      }
+
+      [[nodiscard]] inline bool parse_date_time( const std::string_view v )
+      {
+         static std::regex re( "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:[0-5]\\d)$" );
+         if( !std::regex_search( v.begin(), v.end(), re ) ) {
+            return false;
+         }
+
+         const unsigned year = ( v[ 0 ] - '0' ) * 1000 + ( v[ 1 ] - '0' ) * 100 + ( v[ 2 ] - '0' ) * 10 + ( v[ 3 ] - '0' );
+         const unsigned month = ( v[ 5 ] - '0' ) * 10 + ( v[ 6 ] - '0' );
+         const unsigned day = ( v[ 8 ] - '0' ) * 10 + ( v[ 9 ] - '0' );
+
+         if( month == 0 || month > 12 ) {
+            return false;
+         }
+         if( day == 0 || day > 31 ) {
+            return false;
+         }
+         if( month == 2 ) {
+            const bool is_leap_year = ( year % 4 == 0 ) && ( year % 100 != 0 || year % 400 == 0 );
+            if( day > ( is_leap_year ? 29U : 28U ) ) {
+               return false;
+            }
+         }
+         else if( day == 31 ) {
+            switch( month ) {
+               case 4:
+               case 6:
+               case 9:
+               case 11:
+                  return false;
+               default:;
+            }
+         }
+
+         const unsigned hour = ( v[ 11 ] - '0' ) * 10 + ( v[ 12 ] - '0' );
+         if( hour >= 24 ) {
+            return false;
+         }
+
+         if( *v.rbegin() != 'Z' ) {
+            const auto s = v.size();
+            const unsigned tz_hour = ( v[ s - 5 ] - '0' ) * 10 + ( v[ s - 4 ] - '0' );
+            if( tz_hour >= 24 ) {
+               return false;
+            }
+         }
+
+         return true;
+      }
+
+      enum schema_flags
+      {
+         NONE = 0,
+
+         HAS_TYPE = 1 << 0,
+         NULL_ = 1 << 1,
+         BOOLEAN = 1 << 2,
+         INTEGER = 1 << 3,
+         NUMBER = 1 << 4,
+         STRING = 1 << 5,
+         ARRAY = 1 << 6,
+         OBJECT = 1 << 7,
+
+         HAS_ENUM = 1 << 8,
+
+         HAS_MULTIPLE_OF_UNSIGNED = 1 << 9,
+         HAS_MULTIPLE_OF_DOUBLE = 1 << 10,
+         HAS_MULTIPLE_OF = 3 << 9,
+
+         HAS_MAXIMUM_SIGNED = 1 << 11,
+         HAS_MAXIMUM_UNSIGNED = 1 << 12,
+         HAS_MAXIMUM_DOUBLE = 3 << 11,
+         HAS_MAXIMUM = 3 << 11,
+         EXCLUSIVE_MAXIMUM = 1 << 13,
+
+         HAS_MINIMUM_SIGNED = 1 << 14,
+         HAS_MINIMUM_UNSIGNED = 1 << 15,
+         HAS_MINIMUM_DOUBLE = 3 << 14,
+         HAS_MINIMUM = 3 << 14,
+         EXCLUSIVE_MINIMUM = 1 << 16,
+
+         HAS_MAX_LENGTH = 1 << 17,
+         HAS_MIN_LENGTH = 1 << 18,
+
+         HAS_MAX_ITEMS = 1 << 19,
+         HAS_MIN_ITEMS = 1 << 20,
+         HAS_UNIQUE_ITEMS = 1 << 21,
+
+         HAS_MAX_PROPERTIES = 1 << 22,
+         HAS_MIN_PROPERTIES = 1 << 23,
+         NO_ADDITIONAL_PROPERTIES = 1 << 24,
+         HAS_DEPENDENCIES = 1 << 25
+      };
+
+      enum class schema_format
+      {
+         none,
+         date_time,
+         email,
+         hostname,
+         ipv4,
+         ipv6,
+         uri
+      };
+
+      [[nodiscard]] inline constexpr schema_flags operator|( const schema_flags lhs, const schema_flags rhs ) noexcept
+      {
+         return static_cast< schema_flags >( static_cast< std::underlying_type< schema_flags >::type >( lhs ) | static_cast< std::underlying_type< schema_flags >::type >( rhs ) );
+      }
+
+      union schema_limit
+      {
+         std::int64_t i;
+         std::uint64_t u;
+         double d;
+      };
+
+      template< template< typename... > class Traits >
+      class schema_container;
+
+      template< template< typename... > class Traits >
+      struct schema_node
+      {
+         const schema_container< Traits >* m_container;
+         const basic_value< Traits >* m_value;
+         const basic_value< Traits >* m_all_of = nullptr;
+         const basic_value< Traits >* m_any_of = nullptr;
+         const basic_value< Traits >* m_one_of = nullptr;
+         const basic_value< Traits >* m_not = nullptr;
+         const basic_value< Traits >* m_items = nullptr;
+         const basic_value< Traits >* m_additional_items = nullptr;
+         const basic_value< Traits >* m_properties = nullptr;
+         const basic_value< Traits >* m_additional_properties = nullptr;
+
+         std::map< std::string, std::set< std::string > > m_property_dependencies;
+         std::map< std::string, const basic_value< Traits >* > m_schema_dependencies;
+
+         std::vector< std::pair< std::regex, const basic_value< Traits >* > > m_pattern_properties;
+
+         std::set< const basic_value< Traits >* > m_referenced_pointers;
+
+         // number
+         schema_limit m_multiple_of;
+         schema_limit m_maximum;
+         schema_limit m_minimum;
+
+         // string
+         std::uint64_t m_max_length;
+         std::uint64_t m_min_length;
+         std::unique_ptr< std::regex > m_pattern;
+
+         // array
+         std::uint64_t m_max_items;
+         std::uint64_t m_min_items;
+
+         // object
+         std::uint64_t m_max_properties;
+         std::uint64_t m_min_properties;
+         std::set< std::string > m_required;
+
+         schema_flags m_flags = NONE;
+         schema_format m_format = schema_format::none;
+
+         void add_type( const schema_flags v )
+         {
+            if( ( m_flags & v ) != 0 ) {
+               throw std::runtime_error( "invalid JSON Schema: duplicate primitive type" );
+            }
+            m_flags = m_flags | v;
+         }
+
+         void add_type( const std::string& v )
+         {
+            if( !v.empty() ) {
+               switch( v[ 0 ] ) {
+                  case 'n':
+                     if( v == "number" ) {
+                        return add_type( NUMBER );
+                     }
+                     else if( v == "null" ) {
+                        return add_type( NULL_ );
+                     }
+                     break;
+                  case 'b':
+                     if( v == "boolean" ) {
+                        return add_type( BOOLEAN );
+                     }
+                     break;
+                  case 'i':
+                     if( v == "integer" ) {
+                        return add_type( INTEGER );
+                     }
+                     break;
+                  case 's':
+                     if( v == "string" ) {
+                        return add_type( STRING );
+                     }
+                     break;
+                  case 'a':
+                     if( v == "array" ) {
+                        return add_type( ARRAY );
+                     }
+                     break;
+                  case 'o':
+                     if( v == "object" ) {
+                        return add_type( OBJECT );
+                     }
+                     break;
+               }
+            }
+            throw std::runtime_error( "invalid JSON Schema: invalid primitive type '" + v + '\'' );
+         }
+
+         [[nodiscard]] const basic_value< Traits >* find( const char* s ) const
+         {
+            const auto* p = m_value->find( s );
+            if( p != nullptr ) {
+               p = &p->skip_value_ptr();
+            }
+            return p;
+         }
+
+         schema_node( const schema_container< Traits >* c, const basic_value< Traits >& v )
+            : m_container( c ),
+              m_value( &v )
+         {
+            // general
+            if( !m_value->is_object() ) {
+               throw std::runtime_error( "invalid JSON Schema: a schema must be of type 'object'" );
+            }
+
+            // title
+            if( const auto* p = find( "title" ) ) {
+               if( !p->is_string() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"title\" must be of type 'string'" );
+               }
+            }
+
+            // description
+            if( const auto* p = find( "description" ) ) {
+               if( !p->is_string() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"description\" must be of type 'string'" );
+               }
+            }
+
+            // type
+            if( const auto* p = find( "type" ) ) {
+               switch( p->type() ) {
+                  case type::STRING:
+                     add_type( p->get_string() );
+                     break;
+                  case type::ARRAY:
+                     for( const auto& e : p->get_array() ) {
+                        if( !e.is_string() ) {
+                           throw std::runtime_error( "invalid JSON Schema: elements in array \"type\" must be of type 'string'" );
+                        }
+                        add_type( e.get_string() );
+                     }
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"type\" must be of type 'string' or 'array'" );
+               }
+               m_flags = m_flags | HAS_TYPE;
+            }
+
+            // enum
+            if( const auto* p = find( "enum" ) ) {
+               if( !p->is_array() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"enum\" must be of type 'array'" );
+               }
+               m_flags = m_flags | HAS_ENUM;
+            }
+
+            // allOf
+            if( const auto* p = find( "allOf" ) ) {
+               if( !p->is_array() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"allOf\" must be of type 'array'" );
+               }
+               if( p->get_array().empty() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"allOf\" must have at least one element" );
+               }
+               for( const auto& e : p->get_array() ) {
+                  m_referenced_pointers.insert( &e.skip_value_ptr() );
+               }
+               m_all_of = p;
+            }
+
+            // anyOf
+            if( const auto* p = find( "anyOf" ) ) {
+               if( !p->is_array() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"anyOf\" must be of type 'array'" );
+               }
+               if( p->get_array().empty() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"anyOf\" must have at least one element" );
+               }
+               for( const auto& e : p->get_array() ) {
+                  m_referenced_pointers.insert( &e.skip_value_ptr() );
+               }
+               m_any_of = p;
+            }
+
+            // oneOf
+            if( const auto* p = find( "oneOf" ) ) {
+               if( !p->is_array() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"oneOf\" must be of type 'array'" );
+               }
+               if( p->get_array().empty() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"oneOf\" must have at least one element" );
+               }
+               for( const auto& e : p->get_array() ) {
+                  m_referenced_pointers.insert( &e.skip_value_ptr() );
+               }
+               m_one_of = p;
+            }
+
+            // not
+            if( const auto* p = find( "not" ) ) {
+               m_referenced_pointers.insert( p );
+               m_not = p;
+            }
+
+            // definitions
+            if( const auto* p = find( "definitions" ) ) {
+               if( !p->is_object() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"definitions\" must be of type 'object'" );
+               }
+               for( const auto& e : p->get_object() ) {
+                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
+               }
+            }
+
+            // multipleOf
+            if( const auto* p = find( "multipleOf" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i <= 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
+                     }
+                     m_multiple_of.u = i;
+                     m_flags = m_flags | HAS_MULTIPLE_OF_UNSIGNED;
+                  } break;
+                  case type::UNSIGNED: {
+                     const auto u = p->get_unsigned();
+                     if( u == 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
+                     }
+                     m_multiple_of.u = u;
+                     m_flags = m_flags | HAS_MULTIPLE_OF_UNSIGNED;
+                  } break;
+                  case type::DOUBLE: {
+                     const auto d = p->get_double();
+                     if( d <= 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
+                     }
+                     m_multiple_of.d = d;
+                     m_flags = m_flags | HAS_MULTIPLE_OF_DOUBLE;
+                  } break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be of type 'number'" );
+               }
+            }
+
+            // maximum
+            if( const auto* p = find( "maximum" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED:
+                     m_maximum.i = p->get_signed();
+                     m_flags = m_flags | HAS_MAXIMUM_SIGNED;
+                     break;
+                  case type::UNSIGNED:
+                     m_maximum.u = p->get_unsigned();
+                     m_flags = m_flags | HAS_MAXIMUM_UNSIGNED;
+                     break;
+                  case type::DOUBLE:
+                     m_maximum.d = p->get_double();
+                     m_flags = m_flags | HAS_MAXIMUM_DOUBLE;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"maximum\" must be of type 'number'" );
+               }
+            }
+
+            // exclusiveMaximum
+            if( const auto* p = find( "exclusiveMaximum" ) ) {
+               if( !p->is_boolean() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMaximum\" must be of type 'boolean'" );
+               }
+               if( ( m_flags & HAS_MAXIMUM ) == 0 ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMaximum\" requires presence of \"maximum\"" );
+               }
+               if( p->get_boolean() ) {
+                  m_flags = m_flags | EXCLUSIVE_MAXIMUM;
+               }
+            }
+
+            // minimum
+            if( const auto* p = find( "minimum" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED:
+                     m_minimum.i = p->get_signed();
+                     m_flags = m_flags | HAS_MINIMUM_SIGNED;
+                     break;
+                  case type::UNSIGNED:
+                     m_minimum.u = p->get_unsigned();
+                     m_flags = m_flags | HAS_MINIMUM_UNSIGNED;
+                     break;
+                  case type::DOUBLE:
+                     m_minimum.d = p->get_double();
+                     m_flags = m_flags | HAS_MINIMUM_DOUBLE;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"minimum\" must be of type 'number'" );
+               }
+            }
+
+            // exclusiveMinimum
+            if( const auto* p = find( "exclusiveMinimum" ) ) {
+               if( !p->is_boolean() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMinimum\" must be of type 'boolean'" );
+               }
+               if( ( m_flags & HAS_MINIMUM ) == 0 ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMinimum\" requires presence of \"minimum\"" );
+               }
+               if( p->get_boolean() ) {
+                  m_flags = m_flags | EXCLUSIVE_MINIMUM;
+               }
+            }
+
+            // maxLength
+            if( const auto* p = find( "maxLength" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"maxLength\" must be greater than or equal to zero" );
+                     }
+                     m_max_length = i;
+                     m_flags = m_flags | HAS_MAX_LENGTH;
+                  } break;
+                  case type::UNSIGNED:
+                     m_max_length = p->get_unsigned();
+                     m_flags = m_flags | HAS_MAX_LENGTH;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"maxLength\" must be of type 'integer'" );
+               }
+            }
+
+            // minLength
+            if( const auto* p = find( "minLength" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"minLength\" must be greater than or equal to zero" );
+                     }
+                     if( i > 0 ) {
+                        m_min_length = i;
+                        m_flags = m_flags | HAS_MIN_LENGTH;
+                     }
+                  } break;
+                  case type::UNSIGNED: {
+                     const auto u = p->get_unsigned();
+                     if( u > 0 ) {
+                        m_min_length = u;
+                        m_flags = m_flags | HAS_MIN_LENGTH;
+                     }
+                  } break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"minLength\" must be of type 'integer'" );
+               }
+            }
+
+            // pattern
+            if( const auto* p = find( "pattern" ) ) {
+               if( !p->is_string() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"pattern\" must be of type 'string'" );
+               }
+               try {
+                  m_pattern = std::make_unique< std::regex >( p->get_string() );
+               }
+               catch( const std::regex_error& e ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"pattern\" must be a regular expression: " + std::string( e.what() ) );
+               }
+            }
+
+            // format
+            // TODO: offer an option to disable "format" support?
+            if( const auto* p = find( "format" ) ) {
+               if( !p->is_string() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"format\" must be of type 'string'" );
+               }
+               const auto& s = p->get_string();
+               if( s == "date-time" ) {
+                  m_format = schema_format::date_time;
+               }
+               else if( s == "email" ) {
+                  m_format = schema_format::email;
+               }
+               else if( s == "hostname" ) {
+                  m_format = schema_format::hostname;
+               }
+               else if( s == "ipv4" ) {
+                  m_format = schema_format::ipv4;
+               }
+               else if( s == "ipv6" ) {
+                  m_format = schema_format::ipv6;
+               }
+               else if( s == "uri" ) {
+                  m_format = schema_format::uri;
+               }
+               // unknown "format" values are ignored
+            }
+
+            // items
+            if( const auto* p = find( "items" ) ) {
+               if( p->is_array() ) {
+                  for( const auto& e : p->get_array() ) {
+                     m_referenced_pointers.insert( &e.skip_value_ptr() );
+                  }
+               }
+               else if( p->is_object() ) {
+                  m_referenced_pointers.insert( p );
+               }
+               else {
+                  throw std::runtime_error( "invalid JSON Schema: \"items\" must be of type 'object' or 'array'" );
+               }
+               m_items = p;
+            }
+
+            // additionalItems
+            if( const auto* p = find( "additionalItems" ) ) {
+               if( p->is_object() ) {
+                  m_referenced_pointers.insert( p );
+               }
+               else if( !p->is_boolean() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"additionalItems\" must be of type 'boolean' or 'object'" );
+               }
+               m_additional_items = p;
+            }
+
+            // maxItems
+            if( const auto* p = find( "maxItems" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"maxItems\" must be greater than or equal to zero" );
+                     }
+                     m_max_items = i;
+                     m_flags = m_flags | HAS_MAX_ITEMS;
+                  } break;
+                  case type::UNSIGNED:
+                     m_max_items = p->get_unsigned();
+                     m_flags = m_flags | HAS_MAX_ITEMS;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"maxItems\" must be of type 'integer'" );
+               }
+            }
+
+            // minItems
+            if( const auto* p = find( "minItems" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"minItems\" must be greater than or equal to zero" );
+                     }
+                     m_min_items = i;
+                     m_flags = m_flags | HAS_MIN_ITEMS;
+                  } break;
+                  case type::UNSIGNED:
+                     m_min_items = p->get_unsigned();
+                     m_flags = m_flags | HAS_MIN_ITEMS;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"minItems\" must be of type 'integer'" );
+               }
+            }
+
+            // uniqueItems
+            if( const auto* p = find( "uniqueItems" ) ) {
+               if( p->get_boolean() ) {
+                  m_flags = m_flags | HAS_UNIQUE_ITEMS;
+               }
+            }
+
+            // maxProperties
+            if( const auto* p = find( "maxProperties" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"maxProperties\" must be greater than or equal to zero" );
+                     }
+                     m_max_properties = i;
+                     m_flags = m_flags | HAS_MAX_PROPERTIES;
+                  } break;
+                  case type::UNSIGNED:
+                     m_max_properties = p->get_unsigned();
+                     m_flags = m_flags | HAS_MAX_PROPERTIES;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"maxProperties\" must be of type 'integer'" );
+               }
+            }
+
+            // minProperties
+            if( const auto* p = find( "minProperties" ) ) {
+               switch( p->type() ) {
+                  case type::SIGNED: {
+                     const auto i = p->get_signed();
+                     if( i < 0 ) {
+                        throw std::runtime_error( "invalid JSON Schema: \"minProperties\" must be greater than or equal to zero" );
+                     }
+                     m_min_properties = i;
+                     m_flags = m_flags | HAS_MIN_PROPERTIES;
+                  } break;
+                  case type::UNSIGNED:
+                     m_min_properties = p->get_unsigned();
+                     m_flags = m_flags | HAS_MIN_PROPERTIES;
+                     break;
+                  default:
+                     throw std::runtime_error( "invalid JSON Schema: \"minProperties\" must be of type 'integer'" );
+               }
+            }
+
+            // required
+            if( const auto* p = find( "required" ) ) {
+               if( !p->is_array() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"required\" must be of type 'array'" );
+               }
+               if( p->get_array().empty() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"required\" must have at least one element" );
+               }
+               for( const auto& e : p->get_array() ) {
+                  if( !m_required.insert( e.get_string() ).second ) {
+                     throw std::runtime_error( "invalid JSON Schema: duplicate required key" );
+                  }
+               }
+            }
+
+            // properties
+            if( const auto* p = find( "properties" ) ) {
+               if( !p->is_object() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"properties\" must be of type 'object'" );
+               }
+               for( const auto& e : p->get_object() ) {
+                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
+               }
+               m_properties = p;
+            }
+
+            // patternProperties
+            if( const auto* p = find( "patternProperties" ) ) {
+               if( !p->is_object() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"patternProperties\" must be of type 'object'" );
+               }
+               for( const auto& e : p->get_object() ) {
+                  try {
+                     m_pattern_properties.emplace_back( std::regex( e.first ), &e.second.skip_value_ptr() );
+                  }
+                  catch( const std::regex_error& ex ) {
+                     throw std::runtime_error( "invalid JSON Schema: keys in object \"patternProperties\" must be regular expressions: " + std::string( ex.what() ) );
+                  }
+                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
+               }
+            }
+
+            // additionalProperties
+            if( const auto* p = find( "additionalProperties" ) ) {
+               const type t = p->type();
+               if( t == type::OBJECT ) {
+                  m_referenced_pointers.insert( p );
+               }
+               else if( t != type::BOOLEAN ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"additionalProperties\" must be of type 'boolean' or 'object'" );
+               }
+               m_additional_properties = p;
+            }
+
+            // dependencies
+            if( const auto* p = find( "dependencies" ) ) {
+               if( !p->is_object() ) {
+                  throw std::runtime_error( "invalid JSON Schema: \"dependencies\" must be of type 'object'" );
+               }
+               for( const auto& e : p->get_object() ) {
+                  const auto* p2 = &e.second.skip_value_ptr();
+                  if( p2->is_object() ) {
+                     m_schema_dependencies.emplace( e.first, p2 );
+                     m_referenced_pointers.insert( p2 );
+                  }
+                  else if( p2->is_array() ) {
+                     if( p2->get_array().empty() ) {
+                        throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must have at least one element" );
+                     }
+                     std::set< std::string > s;
+                     for( const auto& r : p2->get_array() ) {
+                        if( !r.is_string() ) {
+                           throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must contain elements of type 'string'" );
+                        }
+                        if( !s.emplace( r.get_string() ).second ) {
+                           throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must contain unique elements of type 'string'" );
+                        }
+                     }
+                     m_property_dependencies.emplace( e.first, std::move( s ) );
+                  }
+                  else {
+                     throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" must be of type 'object' or 'array'" );
+                  }
+               }
+               if( !p->get_object().empty() ) {
+                  m_flags = m_flags | HAS_DEPENDENCIES;
+               }
+            }
+
+            // default
+            if( const auto* p = find( "default" ) ) {
+               // TODO: the value should validate against the JSON Schema itself
+            }
+         }
+
+         schema_node( const schema_node& ) = delete;
+         schema_node( schema_node&& ) = delete;
+
+         ~schema_node() = default;
+
+         void operator=( const schema_node& ) = delete;
+         void operator=( schema_node&& ) = delete;
+
+         [[nodiscard]] const std::set< const basic_value< Traits >* >& referenced_pointers() const noexcept
+         {
+            return m_referenced_pointers;
+         }
+      };
+
+      template< template< typename... > class Traits >
+      class schema_consumer
+      {
+      private:
+         const std::shared_ptr< const schema_container< Traits > > m_container;
+         const schema_node< Traits >* const m_node;
+
+         std::vector< std::unique_ptr< events_compare< Traits > > > m_enum;
+         std::unique_ptr< events::hash > m_hash;
+         std::set< std::string > m_unique;
+         std::set< std::string > m_keys;
+         std::vector< std::size_t > m_count;
+         std::vector< std::unique_ptr< schema_consumer > > m_properties;
+         std::vector< std::unique_ptr< schema_consumer > > m_all_of;
+         std::vector< std::unique_ptr< schema_consumer > > m_any_of;
+         std::vector< std::unique_ptr< schema_consumer > > m_one_of;
+         std::map< std::string, std::unique_ptr< schema_consumer > > m_schema_dependencies;
+         std::unique_ptr< schema_consumer > m_not;
+         std::unique_ptr< schema_consumer > m_item;
+         bool m_match = true;
+
+         void validate_type( const schema_flags t )
+         {
+            if( !m_count.empty() ) {
+               return;
+            }
+            if( ( m_node->m_flags & HAS_TYPE ) == 0 ) {
+               return;
+            }
+            if( ( m_node->m_flags & t ) == 0 ) {
+               m_match = false;
+            }
+         }
+
+         // note: lambda returns true if validation failure detected
+         template< typename F >
+         void validate_enum( F&& f )
+         {
+            assert( m_match );
+            if( m_node->m_flags & HAS_ENUM ) {
+               m_enum.erase( std::remove_if( m_enum.begin(), m_enum.end(), [&]( const std::unique_ptr< events_compare< Traits > >& p ) { return f( *p ); } ), m_enum.end() );
+               if( m_enum.empty() ) {
+                  m_match = false;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_item( F&& f )
+         {
+            if( m_item ) {
+               if( f( m_item ) ) {
+                  m_match = false;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_properties( F&& f )
+         {
+            for( auto& p : m_properties ) {
+               if( f( p ) ) {
+                  m_match = false;
+                  break;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_schema_dependencies( F&& f )
+         {
+            auto it = m_schema_dependencies.begin();
+            while( it != m_schema_dependencies.end() ) {
+               if( f( it->second ) ) {
+                  it = m_schema_dependencies.erase( it );
+               }
+               else {
+                  ++it;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_all_of( F&& f )
+         {
+            for( auto& p : m_all_of ) {
+               if( f( p ) ) {
+                  m_match = false;
+                  break;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_any_of( F&& f )
+         {
+            if( !m_any_of.empty() ) {
+               m_any_of.erase( std::remove_if( m_any_of.begin(), m_any_of.end(), f ), m_any_of.end() );
+               if( m_any_of.empty() ) {
+                  m_match = false;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_one_of( F&& f )
+         {
+            if( !m_one_of.empty() ) {
+               m_one_of.erase( std::remove_if( m_one_of.begin(), m_one_of.end(), f ), m_one_of.end() );
+               if( m_one_of.empty() ) {
+                  m_match = false;
+               }
+            }
+         }
+
+         template< typename F >
+         void validate_not( F&& f )
+         {
+            if( m_not ) {
+               if( f( m_not ) ) {
+                  m_not.reset();
+               }
+            }
+         }
+
+         // note: lambda returns true if validation failure detected
+         template< typename F >
+         void validate_collections( F&& f )
+         {
+            assert( m_match );
+            const auto f2 = [&]( const std::unique_ptr< schema_consumer >& p ) { return f( *p ); };
+            if( m_match ) {
+               validate_item( f2 );
+            }
+            if( m_match ) {
+               validate_properties( f2 );
+            }
+            if( m_match ) {
+               validate_all_of( f2 );
+            }
+            if( m_match ) {
+               validate_any_of( f2 );
+            }
+            if( m_match ) {
+               validate_one_of( f2 );
+            }
+            if( m_match ) {
+               validate_not( f2 );
+            }
+            if( m_match ) {
+               validate_schema_dependencies( f2 );
+            }
+         }
+
+         [[nodiscard]] static bool is_multiple_of( const double v, const double d )
+         {
+            const auto r = std::fmod( v, d );
+            if( std::fabs( r ) < std::numeric_limits< double >::epsilon() ) {
+               return true;
+            }
+            if( std::fabs( r - d ) < std::numeric_limits< double >::epsilon() ) {
+               return true;
+            }
+            return false;
+         }
+
+         void validate_multiple_of( const std::int64_t v )
+         {
+            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
+               case HAS_MULTIPLE_OF_UNSIGNED:
+                  if( v < 0 ) {
+                     if( ( -v % m_node->m_multiple_of.u ) != 0 ) {
+                        m_match = false;
+                     }
+                  }
+                  else {
+                     if( ( v % m_node->m_multiple_of.u ) != 0 ) {
+                        m_match = false;
+                     }
+                  }
+                  break;
+               case HAS_MULTIPLE_OF_DOUBLE:
+                  if( !is_multiple_of( double( v ), m_node->m_multiple_of.d ) ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_multiple_of( const std::uint64_t v )
+         {
+            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
+               case HAS_MULTIPLE_OF_UNSIGNED:
+                  if( ( v % m_node->m_multiple_of.u ) != 0 ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MULTIPLE_OF_DOUBLE:
+                  if( !is_multiple_of( double( v ), m_node->m_multiple_of.d ) ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_multiple_of( const double v )
+         {
+            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
+               case HAS_MULTIPLE_OF_UNSIGNED:
+                  if( !is_multiple_of( v, double( m_node->m_multiple_of.u ) ) ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MULTIPLE_OF_DOUBLE:
+                  if( !is_multiple_of( v, m_node->m_multiple_of.d ) ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_number( const std::int64_t v )
+         {
+            validate_multiple_of( v );
+            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
+               case HAS_MAXIMUM_SIGNED:
+                  if( v > m_node->m_maximum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED:
+                  if( v >= 0 && static_cast< std::uint64_t >( v ) > m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
+                  if( v >= 0 && static_cast< std::uint64_t >( v ) >= m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE:
+                  if( v > m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
+               case HAS_MINIMUM_SIGNED:
+                  if( v < m_node->m_minimum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED:
+                  if( v < 0 || static_cast< std::uint64_t >( v ) < m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
+                  if( v < 0 || static_cast< std::uint64_t >( v ) <= m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE:
+                  if( v < m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_number( const std::uint64_t v )
+         {
+            validate_multiple_of( v );
+            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
+               case HAS_MAXIMUM_SIGNED:
+                  if( m_node->m_maximum.i < 0 || v > static_cast< std::uint64_t >( m_node->m_maximum.i ) ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
+                  if( m_node->m_maximum.i < 0 || v >= static_cast< std::uint64_t >( m_node->m_maximum.i ) ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED:
+                  if( v > m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE:
+                  if( v > m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
+               case HAS_MINIMUM_SIGNED:
+                  if( m_node->m_minimum.i >= 0 && v < static_cast< std::uint64_t >( m_node->m_minimum.i ) ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
+                  if( m_node->m_minimum.i >= 0 && v <= static_cast< std::uint64_t >( m_node->m_minimum.i ) ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED:
+                  if( v < m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE:
+                  if( v < m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_number( const double v )
+         {
+            validate_multiple_of( v );
+            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
+               case HAS_MAXIMUM_SIGNED:
+                  if( v > m_node->m_maximum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED:
+                  if( v > m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE:
+                  if( v > m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
+                  if( v >= m_node->m_maximum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
+               case HAS_MINIMUM_SIGNED:
+                  if( v < m_node->m_minimum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.i ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED:
+                  if( v < m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.u ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE:
+                  if( v < m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
+                  if( v <= m_node->m_minimum.d ) {
+                     m_match = false;
+                  }
+                  break;
+            }
+         }
+
+         void validate_string( const std::string_view v )
+         {
+            if( m_node->m_flags & HAS_MAX_LENGTH && v.size() > m_node->m_max_length ) {
+               m_match = false;
+            }
+            if( m_node->m_flags & HAS_MIN_LENGTH && v.size() < m_node->m_min_length ) {
+               m_match = false;
+            }
+            if( m_match && m_node->m_pattern ) {
+               if( !std::regex_search( v.begin(), v.end(), *m_node->m_pattern ) ) {
+                  m_match = false;
+               }
+            }
+            if( m_match && m_node->m_format != schema_format::none ) {
+               switch( m_node->m_format ) {
+                  case schema_format::date_time:
+                     if( !internal::parse_date_time( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::email:
+                     if( ( v.size() > 255 ) || !internal::parse< internal::email >( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::hostname:
+                     if( ( v.size() > 255 ) || !internal::parse< internal::hostname >( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::ipv4:
+                     if( !internal::parse< pegtl::uri::IPv4address >( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::ipv6:
+                     if( !internal::parse< pegtl::uri::IPv6address >( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::uri:
+                     // TODO: What rule exactly should we apply here?? JSON Schema is not exactly the best spec I've ever read...
+                     if( !internal::parse< pegtl::uri::URI >( v ) ) {
+                        m_match = false;
+                     }
+                     break;
+                  case schema_format::none:;
+               }
+            }
+         }
+
+         void validate_elements( const std::size_t v )
+         {
+            if( m_node->m_flags & HAS_MAX_ITEMS && v > m_node->m_max_items ) {
+               m_match = false;
+            }
+            if( m_node->m_flags & HAS_MIN_ITEMS && v < m_node->m_min_items ) {
+               m_match = false;
+            }
+         }
+
+         void validate_members( const std::size_t v )
+         {
+            if( m_node->m_flags & HAS_MAX_PROPERTIES && v > m_node->m_max_properties ) {
+               m_match = false;
+            }
+            if( m_node->m_flags & HAS_MIN_PROPERTIES && v < m_node->m_min_properties ) {
+               m_match = false;
+            }
+         }
+
+      public:
+         schema_consumer( const std::shared_ptr< const schema_container< Traits > >& c, const schema_node< Traits >& n )
+            : m_container( c ),
+              m_node( &n )
+         {
+            if( m_node->m_flags & HAS_ENUM ) {
+               const auto& a = m_node->m_value->at( "enum" ).get_array();
+               m_enum.reserve( a.size() );
+               for( const auto& e : a ) {
+                  m_enum.emplace_back( std::make_unique< events_compare< Traits > >() );
+                  m_enum.back()->push( &e );
+               }
+            }
+            if( const auto* p = m_node->m_all_of ) {
+               for( const auto& e : p->get_array() ) {
+                  m_all_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
+               }
+            }
+            if( const auto* p = m_node->m_any_of ) {
+               for( const auto& e : p->get_array() ) {
+                  m_any_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
+               }
+            }
+            if( const auto* p = m_node->m_one_of ) {
+               for( const auto& e : p->get_array() ) {
+                  m_one_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
+               }
+            }
+            if( const auto* p = m_node->m_not ) {
+               m_not = m_container->consumer( p );
+            }
+            for( const auto& e : m_node->m_schema_dependencies ) {
+               m_schema_dependencies.emplace( e.first, m_container->consumer( e.second ) );
+            }
+         }
+
+         schema_consumer( const schema_consumer& ) = delete;
+         schema_consumer( schema_consumer&& ) = delete;
+
+         ~schema_consumer() = default;
+
+         void operator=( const schema_consumer& ) = delete;
+         void operator=( schema_consumer&& ) = delete;
+
+         [[nodiscard]] bool finalize()
+         {
+            if( m_match && !m_all_of.empty() ) {
+               for( auto& e : m_all_of ) {
+                  if( !e->finalize() ) {
+                     m_match = false;
+                     break;
+                  }
+               }
+            }
+            if( m_match && !m_any_of.empty() ) {
+               m_any_of.erase( std::remove_if( m_any_of.begin(), m_any_of.end(), []( const std::unique_ptr< schema_consumer >& c ) { return !c->finalize(); } ), m_any_of.end() );
+               if( m_any_of.empty() ) {
+                  m_match = false;
+               }
+            }
+            if( m_match && !m_one_of.empty() ) {
+               m_one_of.erase( std::remove_if( m_one_of.begin(), m_one_of.end(), []( const std::unique_ptr< schema_consumer >& c ) { return !c->finalize(); } ), m_one_of.end() );
+               if( m_one_of.size() != 1 ) {
+                  m_match = false;
+               }
+            }
+            if( m_match && m_not && m_not->finalize() ) {
+               m_match = false;
+            }
+            if( m_match && m_node->m_flags & HAS_DEPENDENCIES ) {
+               for( const auto& e : m_node->m_schema_dependencies ) {
+                  if( m_keys.count( e.first ) != 0 ) {
+                     const auto it = m_schema_dependencies.find( e.first );
+                     if( it == m_schema_dependencies.end() ) {
+                        m_match = false;
+                        break;
+                     }
+                     if( !it->second->finalize() ) {
+                        m_match = false;
+                        break;
+                     }
+                  }
+               }
+            }
+            return m_match;
+         }
+
+         [[nodiscard]] bool match() const noexcept
+         {
+            return m_match;
+         }
+
+         void null()
+         {
+            if( m_match ) {
+               validate_type( NULL_ );
+            }
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.null(); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.null(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->null();
+            }
+         }
+
+         void boolean( const bool v )
+         {
+            if( m_match ) {
+               validate_type( BOOLEAN );
+            }
+            if( m_match ) {
+               validate_enum( [=]( events_compare< Traits >& c ) { c.boolean( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [=]( schema_consumer& c ) { c.boolean( v ); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->boolean( v );
+            }
+         }
+
+         void number( const std::int64_t v )
+         {
+            if( m_match ) {
+               validate_type( INTEGER | NUMBER );
+            }
+            if( m_match ) {
+               validate_enum( [=]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [=]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match && m_count.empty() ) {
+               validate_number( v );
+            }
+            if( m_match && m_hash ) {
+               m_hash->number( v );
+            }
+         }
+
+         void number( const std::uint64_t v )
+         {
+            if( m_match ) {
+               validate_type( INTEGER | NUMBER );
+            }
+            if( m_match ) {
+               validate_enum( [=]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [=]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match && m_count.empty() ) {
+               validate_number( v );
+            }
+            if( m_match && m_hash ) {
+               m_hash->number( v );
+            }
+         }
+
+         void number( const double v )
+         {
+            if( m_match ) {
+               validate_type( NUMBER );
+            }
+            if( m_match ) {
+               validate_enum( [=]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [=]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
+            }
+            if( m_match && m_count.empty() ) {
+               validate_number( v );
+            }
+            if( m_match && m_hash ) {
+               m_hash->number( v );
+            }
+         }
+
+         void string( const std::string_view v )
+         {
+            if( m_match ) {
+               validate_type( STRING );
+            }
+            if( m_match ) {
+               validate_enum( [&]( events_compare< Traits >& c ) { c.string( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [&]( schema_consumer& c ) { c.string( v ); return ! c.match(); } );
+            }
+            if( m_match && m_count.empty() ) {
+               validate_string( v );
+            }
+            if( m_match && m_hash ) {
+               m_hash->string( v );
+            }
+         }
+
+         void binary( const tao::binary_view /*unused*/ )
+         {
+            // TODO: What?
+         }
+
+         void begin_array( const std::size_t /*unused*/ = 0 )
+         {
+            if( m_match ) {
+               validate_type( ARRAY );
+            }
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.begin_array(); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.begin_array(); return ! c.match(); } );
+            }
+            if( m_match ) {
+               if( m_hash ) {
+                  m_hash->begin_array();
+               }
+               else if( m_count.empty() && ( ( m_node->m_flags & HAS_UNIQUE_ITEMS ) != 0 ) ) {
+                  m_hash = std::make_unique< events::hash >();
+               }
+            }
+            if( m_match && m_count.empty() ) {
+               if( const auto* p = m_node->m_items ) {
+                  if( p->is_object() ) {
+                     m_item = m_container->consumer( p );
+                  }
+                  else {
+                     const auto& a = p->get_array();
+                     if( !a.empty() ) {
+                        m_item = m_container->consumer( &a[ 0 ].skip_value_ptr() );
+                     }
+                  }
+               }
+               if( !m_item ) {
+                  if( const auto* p = m_node->m_additional_items ) {
+                     if( p->is_object() ) {
+                        m_item = m_container->consumer( p );
+                     }
+                  }
+               }
+            }
+            m_count.push_back( 0 );
+         }
+
+         void element()
+         {
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.element(); return ! c.match(); } );
+            }
+            if( m_match && m_item ) {
+               if( m_count.size() == 1 ) {
+                  if( !m_item->finalize() ) {
+                     m_match = false;
+                  }
+                  m_item.reset();
+               }
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.element(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               if( m_count.size() == 1 ) {
+                  if( !m_unique.emplace( m_hash->value() ).second ) {
+                     m_match = false;
+                  }
+                  m_hash->reset();
+               }
+               else {
+                  m_hash->element();
+               }
+            }
+            const auto next = ++m_count.back();
+            if( m_match && ( m_count.size() == 1 ) ) {
+               if( const auto* p = m_node->m_items ) {
+                  if( p->is_object() ) {
+                     m_item = m_container->consumer( p );
+                  }
+                  else {
+                     const auto& a = p->get_array();
+                     if( next < a.size() ) {
+                        m_item = m_container->consumer( &a[ next ].skip_value_ptr() );
+                     }
+                  }
+               }
+               if( !m_item ) {
+                  if( const auto* p = m_node->m_additional_items ) {
+                     if( p->is_object() ) {
+                        m_item = m_container->consumer( p );
+                     }
+                  }
+               }
+            }
+         }
+
+         void end_array( const std::size_t /*unused*/ = 0 )
+         {
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.end_array(); return ! c.match(); } );
+            }
+            if( m_match && m_item && ( m_count.size() == 1 ) ) {
+               if( !m_item->finalize() ) {
+                  m_match = false;
+               }
+               m_item.reset();
+            }
+            if( m_match && ( m_count.size() == 1 ) ) {
+               if( m_node->m_items && m_node->m_items->is_array() ) {
+                  if( m_node->m_additional_items && m_node->m_additional_items->is_boolean() ) {
+                     if( !m_node->m_additional_items->get_boolean() ) {
+                        if( m_count.back() > m_node->m_items->get_array().size() ) {
+                           m_match = false;
+                        }
+                     }
+                  }
+               }
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.end_array(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->end_array();
+            }
+            if( m_match && ( m_count.size() == 1 ) ) {
+               validate_elements( m_count.back() );
+            }
+            m_count.pop_back();
+         }
+
+         void begin_object( const std::size_t /*unused*/ = 0 )
+         {
+            if( m_match ) {
+               validate_type( OBJECT );
+            }
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.begin_object(); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.begin_object(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->begin_object();
+            }
+            m_count.push_back( 0 );
+         }
+
+         void key( const std::string& v )
+         {
+            if( m_match ) {
+               validate_enum( [&]( events_compare< Traits >& c ) { c.key( v ); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( [&]( schema_consumer& c ) { c.key( v ); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->key( v );
+            }
+            if( m_match && ( m_count.size() == 1 ) && ( m_node->m_flags & HAS_DEPENDENCIES || !m_node->m_required.empty() ) ) {
+               if( !m_keys.insert( v ).second ) {
+                  // duplicate keys immediately invalidate!
+                  // TODO: throw?
+                  m_match = false;
+               }
+            }
+            if( m_match && m_properties.empty() && ( m_count.size() == 1 ) ) {
+               if( const auto* p = m_node->m_properties ) {
+                  const auto& o = p->get_object();
+                  const auto it = o.find( v );
+                  if( it != o.end() ) {
+                     m_properties.push_back( m_container->consumer( &it->second.skip_value_ptr() ) );
+                  }
+               }
+               for( const auto& e : m_node->m_pattern_properties ) {
+                  if( std::regex_search( v, e.first ) ) {
+                     m_properties.push_back( m_container->consumer( e.second ) );
+                  }
+               }
+               if( m_properties.empty() ) {
+                  if( const auto* p = m_node->m_additional_properties ) {
+                     if( p->is_boolean() ) {
+                        if( !p->get_boolean() ) {
+                           m_match = false;
+                        }
+                     }
+                     else {
+                        m_properties.push_back( m_container->consumer( p ) );
+                     }
+                  }
+               }
+            }
+         }
+
+         void key( const std::string_view sv )
+         {
+            key( std::string( sv ) );
+         }
+
+         void key( const char* v )
+         {
+            key( std::string( v ) );
+         }
+
+         void member()
+         {
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.member(); return ! c.match(); } );
+            }
+            if( m_match && !m_properties.empty() && ( m_count.size() == 1 ) ) {
+               for( auto& e : m_properties ) {
+                  if( !e->finalize() ) {
+                     m_match = false;
+                     break;
+                  }
+               }
+               m_properties.clear();
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.member(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->member();
+            }
+            ++m_count.back();
+         }
+
+         void end_object( const std::size_t /*unused*/ = 0 )
+         {
+            if( m_match ) {
+               validate_enum( []( events_compare< Traits >& c ) { c.end_object(); return ! c.match(); } );
+            }
+            if( m_match ) {
+               validate_collections( []( schema_consumer& c ) { c.end_object(); return ! c.match(); } );
+            }
+            if( m_match && m_hash ) {
+               m_hash->end_object();
+            }
+            if( m_match && ( m_count.size() == 1 ) ) {
+               validate_members( m_count.back() );
+            }
+            if( m_match && ( m_count.size() == 1 ) && !m_node->m_required.empty() ) {
+               if( !std::includes( m_keys.begin(), m_keys.end(), m_node->m_required.begin(), m_node->m_required.end() ) ) {
+                  m_match = false;
+               }
+            }
+            if( m_match && ( m_count.size() == 1 ) && m_node->m_flags & HAS_DEPENDENCIES ) {
+               for( const auto& e : m_node->m_property_dependencies ) {
+                  if( m_keys.count( e.first ) != 0 ) {
+                     if( !std::includes( m_keys.begin(), m_keys.end(), e.second.begin(), e.second.end() ) ) {
+                        m_match = false;
+                        break;
+                     }
+                  }
+               }
+            }
+            m_count.pop_back();
+         }
+      };
+
+      template< template< typename... > class Traits >
+      class schema_container
+         : public std::enable_shared_from_this< schema_container< Traits > >
+      {
+      private:
+         basic_value< Traits > m_value;
+
+         using nodes_t = std::map< const basic_value< Traits >*, std::unique_ptr< schema_node< Traits > > >;
+         nodes_t m_nodes;
+
+         void make_node( const basic_value< Traits >* p )
+         {
+            m_nodes.emplace( p, std::make_unique< schema_node< Traits > >( this, *p ) );
+         }
+
+      public:
+         explicit schema_container( const basic_value< Traits >& v )
+            : m_value( v.skip_value_ptr() )
+         {
+            resolve_references( m_value );
+            make_node( &m_value );
+            while( true ) {
+               std::set< const basic_value< Traits >* > required;
+               for( const auto& e : m_nodes ) {
+                  auto s = e.second->referenced_pointers();
+                  required.insert( s.begin(), s.end() );
+               }
+               for( const auto& e : m_nodes ) {
+                  required.erase( e.first );
+               }
+               if( required.empty() ) {
+                  break;
+               }
+               for( const auto& e : required ) {
+                  make_node( e );
+               }
+            }
+         }
+
+         [[nodiscard]] std::unique_ptr< schema_consumer< Traits > > consumer( const basic_value< Traits >* p ) const
+         {
+            const auto it = m_nodes.find( p );
+            if( it == m_nodes.end() ) {
+               throw std::logic_error( "invalid node ptr, no schema registered" );
+            }
+            return std::make_unique< schema_consumer< Traits > >( this->shared_from_this(), *it->second );
+         }
+
+         [[nodiscard]] std::unique_ptr< schema_consumer< Traits > > consumer() const
+         {
+            return consumer( &m_value );
+         }
+      };
+
+   }  // namespace internal
+
+   template< template< typename... > class Traits >
+   class basic_schema
+   {
+   private:
+      const std::shared_ptr< const internal::schema_container< Traits > > m_container;
+
+   public:
+      explicit basic_schema( const basic_value< Traits >& v )
+         : m_container( std::make_shared< internal::schema_container< Traits > >( v ) )
+      {
+      }
+
+      [[nodiscard]] std::unique_ptr< internal::schema_consumer< Traits > > consumer() const
+      {
+         return m_container->consumer();
+      }
+
+      [[nodiscard]] bool validate( const basic_value< Traits >& v ) const
+      {
+         // TODO: Value validation should be implemented independently,
+         // as it could be more efficient than Events validation!
+         const auto c = consumer();
+         events::from_value( *c, v );
+         return c->finalize();
+      }
+   };
+
+   using schema = basic_schema< traits >;
+
+   template< template< typename... > class Traits >
+   [[nodiscard]] basic_schema< Traits > make_schema( const basic_value< Traits >& v )
+   {
+      return basic_schema< Traits >( v );
+   }
+
+}  // namespace tao::json
+
+#endif