Interface Design for HTTP parsing / response

Question

This is my first "real" attempt at decoding an HTTP request on the server side.

This is the interface I think should be sufficient. However, because I am new to the details I would love to get some feedback on whether there is some missing information that a client would like to see.

#ifndef THORSANVIL_NISSE_PYNT_HTTP_H
#define THORSANVIL_NISSE_PYNT_HTTP_H
/*
 * An HTTP implementation of Pynt
 * Version 1:
 */
#include "PyntHTTPConfig.h"
#include "NisseServer/Pynt.h"
#include <string_view>
namespace ThorsAnvil::Nisse
{
enum class Version {HTTP1_0, HTTTP1_1, HTTP2, HTTP3, Uknown};
enum class Method {GET, HEAD, OPTIONS, TRACE, PUT, DELETE, POST, PATCH, CONNECT, Other};
class URL
{
 public:
 std::string_view href(); // 'http://user:pass@localhost:53/status?name=ryan#234'
 std::string_view origin(); // 'http://localhost:53'
 std::string_view protocol(); // 'http:'
 std::string_view username(); // 'user'
 std::string_view password(); // 'pass'
 std::string_view host(); // 'localhost:53',
 std::string_view hostname(); // 'localhost',
 std::string_view port(); // '53'
 std::string_view pathname(); // '/status',
 std::string_view search(); // '?name=ryan',
 std::string_view hash(); // '#234'
 std::string_view param(std::string_view param); // parm('name') => 'ryan'
};
class Header
{
 using CIterator = std::pair<std::string, std::vector<std::string>>;
 using const_iterator = CIterator;
 public:
 std::vector<std::string>& getHeader(std::string_view header);
 bool hasHeader(std::string_view header);
 CIterator begin() const;
 CIterator end() const;
};
class Request
{
 Version httpVersion();
 Method method();
 URL const& url();
 std::string_view httpRawRequest(); // GET /index.html HTTP/1.1
 Header const& headers();
 Header const& trailers(); // Trailers will return an empty Header() if body has not been read.
 // if (body().eof()) Then trailers have been read.
 std::istream& body(); // Can be used to read the stream body.
 // It will auto eof() when no more data is available in the body.
 // Note this stream will auto decode the incoming message body based
 // on the 'content-encoding'
};
class Response
{
 void setStatus(int code, std::string_view message); // If not set default 200 OK
 // Can be modified anytime up to the headers being sent.
 Header& headers(); // Headers will be locked after they are sent. By default this happens when data is sent to the body stream.
 Header& trailers();
 void done(); // Manually indicate complete. Done automatically by destructor.
 // But processes can use this to flush stream immediately if desired.
 std::ostream& body(); // Format of body is determined by the 'content-encoding/content-length' header fields.
 // Note: Headers will be locked after you start writing to the body stream and thus can
 // not be changed from default encoding.
 bool isHeadersSent();
 bool isDone();
};
class PyntHTTP: public Pynt
{
 public:
 virtual PyntResult handleRequest(std::iostream& stream) override;
 virtual PyntResult processRequest(Request const& request, Response& response) = 0;
};
}
#endif

Note: Based on extending the Pynt interface previously described.

Note: Though the interface uses std::istream and std::ostream on the server these are actually implemented by streams that understand how to yield control when reading/writing would block. Thus we get an intuitive interface that is simple to program against but is also efficient.