diff --git a/CMakeLists.txt b/CMakeLists.txt
index 429097b..d1c4dff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-project(fcgi_responder VERSION 1.6.1)
+project(fcgi_responder VERSION 1.6.2)
 
 include(GNUInstallDirs)
 include(external/seal_lake)
diff --git a/src/constants.h b/src/constants.h
index cbe3772..842ddc3 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -4,11 +4,11 @@
 
 namespace fcgi {
 namespace hardcoded {
-const uint8_t protocolVersion = 1;
-const uint8_t keepConnectionMask = 1;
-const uint8_t headerSize = 8;
-const uint32_t maxDataMessageSize = std::numeric_limits<uint16_t>::max();
-const uint32_t maxRecordPaddingSize = std::numeric_limits<uint8_t>::max();
-const uint32_t maxRecordSize = headerSize + maxDataMessageSize + maxRecordPaddingSize;
+const std::uint8_t protocolVersion = 1;
+const std::uint8_t keepConnectionMask = 1;
+const std::uint8_t headerSize = 8;
+const std::uint32_t maxDataMessageSize = std::numeric_limits<std::uint16_t>::max();
+const std::uint32_t maxRecordPaddingSize = std::numeric_limits<std::uint8_t>::max();
+const std::uint32_t maxRecordSize = headerSize + maxDataMessageSize + maxRecordPaddingSize;
 } //namespace hardcoded
 } //namespace fcgi
diff --git a/src/decoder.cpp b/src/decoder.cpp
index 1a00730..4afe5f5 100644
--- a/src/decoder.cpp
+++ b/src/decoder.cpp
@@ -8,13 +8,13 @@ Decoder::Decoder(std::istream& input)
 {
 }
 
-Decoder& Decoder::operator>>(uint8_t& val)
+Decoder& Decoder::operator>>(std::uint8_t& val)
 {
     input_.read(reinterpret_cast<char*>(&val), 1);
     return *this;
 }
 
-Decoder& Decoder::operator>>(uint16_t& val)
+Decoder& Decoder::operator>>(std::uint16_t& val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
     input_.read(valIt, 2);
@@ -24,7 +24,7 @@ Decoder& Decoder::operator>>(uint16_t& val)
     return *this;
 }
 
-Decoder& Decoder::operator>>(uint32_t& val)
+Decoder& Decoder::operator>>(std::uint32_t& val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
     input_.read(valIt, 4);
diff --git a/src/decoder.h b/src/decoder.h
index 16acfad..b7bf26f 100644
--- a/src/decoder.h
+++ b/src/decoder.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <cstdint>
 #include <istream>
 
 namespace fcgi {
@@ -6,9 +7,9 @@ namespace fcgi {
 class Decoder {
 public:
     explicit Decoder(std::istream& input);
-    Decoder& operator>>(uint8_t& val);
-    Decoder& operator>>(uint16_t& val);
-    Decoder& operator>>(uint32_t& val);
+    Decoder& operator>>(std::uint8_t& val);
+    Decoder& operator>>(std::uint16_t& val);
+    Decoder& operator>>(std::uint32_t& val);
     Decoder& operator>>(std::string& val);
 
     void skip(std::size_t numOfBytes);
diff --git a/src/encoder.cpp b/src/encoder.cpp
index 9e8daff..11964d0 100644
--- a/src/encoder.cpp
+++ b/src/encoder.cpp
@@ -8,13 +8,13 @@ Encoder::Encoder(std::ostream& stream)
 {
 }
 
-Encoder& Encoder::operator<<(uint8_t val)
+Encoder& Encoder::operator<<(std::uint8_t val)
 {
     output_.write(reinterpret_cast<const char*>(&val), 1);
     return *this;
 }
 
-Encoder& Encoder::operator<<(uint16_t val)
+Encoder& Encoder::operator<<(std::uint16_t val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
 #ifndef BIG_ENDIAN_HOST
@@ -24,7 +24,7 @@ Encoder& Encoder::operator<<(uint16_t val)
     return *this;
 }
 
-Encoder& Encoder::operator<<(uint32_t val)
+Encoder& Encoder::operator<<(std::uint32_t val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
 #ifndef BIG_ENDIAN_HOST
diff --git a/src/encoder.h b/src/encoder.h
index 4480763..c133619 100644
--- a/src/encoder.h
+++ b/src/encoder.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <cstdint>
 #include <ostream>
 
 namespace fcgi {
@@ -6,9 +7,9 @@ namespace fcgi {
 class Encoder {
 public:
     explicit Encoder(std::ostream& stream);
-    Encoder& operator<<(uint8_t val);
-    Encoder& operator<<(uint16_t val);
-    Encoder& operator<<(uint32_t val);
+    Encoder& operator<<(std::uint8_t val);
+    Encoder& operator<<(std::uint16_t val);
+    Encoder& operator<<(std::uint32_t val);
     Encoder& operator<<(const std::string& val);
 
     void addPadding(std::size_t numOfBytes);
diff --git a/src/errors.cpp b/src/errors.cpp
index 0ba8d5a..fc11427 100644
--- a/src/errors.cpp
+++ b/src/errors.cpp
@@ -8,13 +8,13 @@ ProtocolError::ProtocolError(const std::string& msg)
 {
 }
 
-UnsupportedVersion::UnsupportedVersion(uint8_t protocolVersion)
+UnsupportedVersion::UnsupportedVersion(std::uint8_t protocolVersion)
     : ProtocolError{"Protocol version \"" + std::to_string(protocolVersion) + "\" isn't supported."}
     , protocolVersion_{protocolVersion}
 {
 }
 
-uint8_t UnsupportedVersion::protocolVersion() const
+std::uint8_t UnsupportedVersion::protocolVersion() const
 {
     return protocolVersion_;
 }
@@ -38,7 +38,7 @@ std::string invalidValueTypeToString(InvalidValueType type)
 
 } //namespace
 
-InvalidValue::InvalidValue(InvalidValueType type, uint32_t value)
+InvalidValue::InvalidValue(InvalidValueType type, std::uint32_t value)
     : ProtocolError{""}
     , type_{type}
     , value_{value}
@@ -59,9 +59,9 @@ InvalidValueType InvalidValue::type() const
     return type_;
 }
 
-uint32_t InvalidValue::asInt() const
+std::uint32_t InvalidValue::asInt() const
 {
-    return std::get<uint32_t>(value_);
+    return std::get<std::uint32_t>(value_);
 }
 
 std::string InvalidValue::asString() const
@@ -69,7 +69,7 @@ std::string InvalidValue::asString() const
     if (std::holds_alternative<std::string>(value_))
         return std::get<std::string>(value_);
     else
-        return std::to_string(std::get<uint32_t>(value_));
+        return std::to_string(std::get<std::uint32_t>(value_));
 }
 
 const char* InvalidValue::what() const noexcept
@@ -88,13 +88,13 @@ std::size_t RecordMessageReadError::recordSize() const
     return recordSize_;
 }
 
-InvalidRecordType::InvalidRecordType(uint8_t typeValue)
+InvalidRecordType::InvalidRecordType(std::uint8_t typeValue)
     : ProtocolError{"Record type \"" + std::to_string(typeValue) + "\" is invalid."}
     , typeValue_{typeValue}
 {
 }
 
-uint8_t InvalidRecordType::recordType() const
+std::uint8_t InvalidRecordType::recordType() const
 {
     return typeValue_;
 }
diff --git a/src/errors.h b/src/errors.h
index ca127a4..7fd50cc 100644
--- a/src/errors.h
+++ b/src/errors.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <cstdint>
 #include <stdexcept>
 #include <variant>
 
@@ -11,11 +12,11 @@ class ProtocolError : public std::runtime_error {
 
 class UnsupportedVersion : public ProtocolError {
 public:
-    explicit UnsupportedVersion(uint8_t protocolVersion);
-    uint8_t protocolVersion() const;
+    explicit UnsupportedVersion(std::uint8_t protocolVersion);
+    std::uint8_t protocolVersion() const;
 
 private:
-    uint8_t protocolVersion_;
+    std::uint8_t protocolVersion_;
 };
 
 enum class InvalidValueType {
@@ -27,17 +28,17 @@ enum class InvalidValueType {
 
 class InvalidValue : public ProtocolError {
 public:
-    InvalidValue(InvalidValueType type, uint32_t value);
+    InvalidValue(InvalidValueType type, std::uint32_t value);
     InvalidValue(InvalidValueType type, const std::string& value);
     InvalidValueType type() const;
-    uint32_t asInt() const;
+    std::uint32_t asInt() const;
     std::string asString() const;
 
     const char* what() const noexcept override;
 
 private:
     InvalidValueType type_;
-    std::variant<uint32_t, std::string> value_;
+    std::variant<std::uint32_t, std::string> value_;
     std::string msg_;
 };
 
@@ -52,11 +53,11 @@ class RecordMessageReadError : public ProtocolError {
 
 class InvalidRecordType : public ProtocolError {
 public:
-    explicit InvalidRecordType(uint8_t recordType);
-    uint8_t recordType() const;
+    explicit InvalidRecordType(std::uint8_t recordType);
+    std::uint8_t recordType() const;
 
 private:
-    uint8_t typeValue_;
+    std::uint8_t typeValue_;
 };
 
 } //namespace fcgi
diff --git a/src/msgbeginrequest.cpp b/src/msgbeginrequest.cpp
index e1c2723..ae56949 100644
--- a/src/msgbeginrequest.cpp
+++ b/src/msgbeginrequest.cpp
@@ -30,14 +30,14 @@ ResultConnectionState MsgBeginRequest::resultConnectionState() const
 void MsgBeginRequest::toStream(std::ostream& output) const
 {
     auto encoder = Encoder(output);
-    encoder << static_cast<uint16_t>(role_) << static_cast<uint8_t>(resultConnectionState_);
+    encoder << static_cast<std::uint16_t>(role_) << static_cast<std::uint8_t>(resultConnectionState_);
     encoder.addPadding(5); //reserved bytes
 }
 
 void MsgBeginRequest::fromStream(std::istream& input, std::size_t)
 {
-    auto role = uint16_t{};
-    auto flags = uint8_t{};
+    auto role = std::uint16_t{};
+    auto flags = std::uint8_t{};
     auto decoder = Decoder(input);
     decoder >> role >> flags;
     decoder.skip(5); //reservedBytes
diff --git a/src/msgendrequest.cpp b/src/msgendrequest.cpp
index 4070226..04ae5f8 100644
--- a/src/msgendrequest.cpp
+++ b/src/msgendrequest.cpp
@@ -5,7 +5,7 @@
 
 namespace fcgi {
 
-MsgEndRequest::MsgEndRequest(uint32_t appStatus, ProtocolStatus protocolStatus)
+MsgEndRequest::MsgEndRequest(std::uint32_t appStatus, ProtocolStatus protocolStatus)
     : appStatus_{appStatus}
     , protocolStatus_{protocolStatus}
 {
@@ -16,7 +16,7 @@ std::size_t MsgEndRequest::size()
     return 8;
 }
 
-uint32_t MsgEndRequest::appStatus() const
+std::uint32_t MsgEndRequest::appStatus() const
 {
     return appStatus_;
 }
@@ -29,13 +29,13 @@ ProtocolStatus MsgEndRequest::protocolStatus() const
 void MsgEndRequest::toStream(std::ostream& output) const
 {
     auto encoder = Encoder(output);
-    encoder << appStatus_ << static_cast<uint8_t>(protocolStatus_);
+    encoder << appStatus_ << static_cast<std::uint8_t>(protocolStatus_);
     encoder.addPadding(3); //reserved bytes
 }
 
 void MsgEndRequest::fromStream(std::istream& input, std::size_t)
 {
-    auto protocolStatus = uint8_t{};
+    auto protocolStatus = std::uint8_t{};
     auto decoder = Decoder(input);
     decoder >> appStatus_ >> protocolStatus;
     decoder.skip(3); //reserved bytes
diff --git a/src/msgendrequest.h b/src/msgendrequest.h
index f8c9b01..ea2188d 100644
--- a/src/msgendrequest.h
+++ b/src/msgendrequest.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include <cstdint>
 #include <istream>
 #include <ostream>
 
@@ -11,8 +12,8 @@ class MsgEndRequest {
 
 public:
     MsgEndRequest() = default;
-    MsgEndRequest(uint32_t appStatus, ProtocolStatus protocolStatus);
-    uint32_t appStatus() const;
+    MsgEndRequest(std::uint32_t appStatus, ProtocolStatus protocolStatus);
+    std::uint32_t appStatus() const;
     ProtocolStatus protocolStatus() const;
     static std::size_t size();
 
@@ -23,7 +24,7 @@ class MsgEndRequest {
     friend bool operator==(const MsgEndRequest& lhs, const MsgEndRequest& rhs);
 
 private:
-    uint32_t appStatus_ = 0;
+    std::uint32_t appStatus_ = 0;
     ProtocolStatus protocolStatus_ = ProtocolStatus::UnknownRole;
 };
 
diff --git a/src/msgunknowntype.cpp b/src/msgunknowntype.cpp
index a0fcccb..6879549 100644
--- a/src/msgunknowntype.cpp
+++ b/src/msgunknowntype.cpp
@@ -5,7 +5,7 @@
 
 namespace fcgi {
 
-MsgUnknownType::MsgUnknownType(uint8_t unknownTypeValue)
+MsgUnknownType::MsgUnknownType(std::uint8_t unknownTypeValue)
     : unknownTypeValue_{unknownTypeValue}
 {
 }
@@ -15,7 +15,7 @@ std::size_t MsgUnknownType::size()
     return 8;
 }
 
-uint8_t MsgUnknownType::unknownTypeValue() const
+std::uint8_t MsgUnknownType::unknownTypeValue() const
 {
     return unknownTypeValue_;
 }
diff --git a/src/msgunknowntype.h b/src/msgunknowntype.h
index 909278d..76ee06f 100644
--- a/src/msgunknowntype.h
+++ b/src/msgunknowntype.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include <cstdint>
 #include <istream>
 #include <ostream>
 
@@ -11,8 +12,8 @@ class MsgUnknownType {
 
 public:
     MsgUnknownType() = default;
-    explicit MsgUnknownType(uint8_t unknownTypeValue);
-    uint8_t unknownTypeValue() const;
+    explicit MsgUnknownType(std::uint8_t unknownTypeValue);
+    std::uint8_t unknownTypeValue() const;
     static std::size_t size();
 
     void toStream(std::ostream& output) const;
@@ -22,7 +23,7 @@ class MsgUnknownType {
     friend bool operator==(const MsgUnknownType& lhs, const MsgUnknownType& rhs);
 
 private:
-    uint8_t unknownTypeValue_ = 0;
+    std::uint8_t unknownTypeValue_ = 0;
 };
 
 bool operator==(const MsgUnknownType& lhs, const MsgUnknownType& rhs);
diff --git a/src/namevalue.cpp b/src/namevalue.cpp
index d4b04ed..9f7f94d 100644
--- a/src/namevalue.cpp
+++ b/src/namevalue.cpp
@@ -49,7 +49,7 @@ void NameValue::setValue(const std::string& value)
 
 namespace {
 
-uint32_t readLengthFromStream(std::istream& input)
+std::uint32_t readLengthFromStream(std::istream& input)
 {
     auto ch = char{};
     input.get(ch);
@@ -68,14 +68,14 @@ uint32_t readLengthFromStream(std::istream& input)
 
         length = ((lengthB3 & 0x7f) << 24) + (lengthB2 << 16) + (lengthB1 << 8) + lengthB0;
     }
-    return static_cast<uint32_t>(length);
+    return static_cast<std::uint32_t>(length);
 }
 
-void writeLengthToStream(uint32_t length, std::ostream& output)
+void writeLengthToStream(std::uint32_t length, std::ostream& output)
 {
     auto encoder = Encoder(output);
     if (length <= 127) {
-        encoder << static_cast<uint8_t>(length);
+        encoder << static_cast<std::uint8_t>(length);
     }
     else {
         length |= 0x80000000;
@@ -87,8 +87,8 @@ void writeLengthToStream(uint32_t length, std::ostream& output)
 
 void NameValue::toStream(std::ostream& output) const
 {
-    writeLengthToStream(static_cast<uint32_t>(name_.size()), output);
-    writeLengthToStream(static_cast<uint32_t>(value_.size()), output);
+    writeLengthToStream(static_cast<std::uint32_t>(name_.size()), output);
+    writeLengthToStream(static_cast<std::uint32_t>(value_.size()), output);
     auto encoder = Encoder(output);
     encoder << name_ << value_;
 }
diff --git a/src/record.cpp b/src/record.cpp
index 86f3d53..ad38860 100644
--- a/src/record.cpp
+++ b/src/record.cpp
@@ -12,7 +12,7 @@ Record::Record()
     initMessage();
 }
 
-Record::Record(RecordType type, uint16_t requestId)
+Record::Record(RecordType type, std::uint16_t requestId)
     : type_{type}
     , requestId_{requestId}
 {
@@ -24,7 +24,7 @@ RecordType Record::type() const
     return type_;
 }
 
-uint16_t Record::requestId() const
+std::uint16_t Record::requestId() const
 {
     return requestId_;
 }
@@ -46,12 +46,12 @@ std::size_t Record::fromStream(std::istream& input, std::size_t inputSize)
 
 void Record::write(std::ostream& output) const
 {
-    auto contentLength = static_cast<uint16_t>(messageSize());
+    auto contentLength = static_cast<std::uint16_t>(messageSize());
     auto paddingLength = calcPaddingLength();
-    auto reservedByte = uint8_t{};
+    auto reservedByte = std::uint8_t{};
 
     auto encoder = Encoder(output);
-    encoder << hardcoded::protocolVersion << static_cast<uint8_t>(type_) << requestId_ << contentLength << paddingLength
+    encoder << hardcoded::protocolVersion << static_cast<std::uint8_t>(type_) << requestId_ << contentLength << paddingLength
             << reservedByte;
     writeMessage(output);
     encoder.addPadding(paddingLength);
@@ -63,15 +63,15 @@ std::size_t Record::read(std::istream& input, std::size_t inputSize)
         return 0;
 
     auto decoder = Decoder(input);
-    auto protocolVersion = uint8_t{};
+    auto protocolVersion = std::uint8_t{};
     decoder >> protocolVersion;
     if (protocolVersion != hardcoded::protocolVersion)
         throw UnsupportedVersion(protocolVersion);
 
-    auto type = uint8_t{};
-    auto contentLength = uint16_t{};
-    auto paddingLength = uint8_t{};
-    auto reservedByte = uint8_t{};
+    auto type = std::uint8_t{};
+    auto contentLength = std::uint16_t{};
+    auto paddingLength = std::uint8_t{};
+    auto reservedByte = std::uint8_t{};
     decoder >> type >> requestId_ >> contentLength >> paddingLength >> reservedByte;
 
     auto recordSize = static_cast<std::size_t>(hardcoded::headerSize + contentLength + paddingLength);
@@ -79,7 +79,7 @@ std::size_t Record::read(std::istream& input, std::size_t inputSize)
         type_ = recordTypeFromInt(type);
     }
     catch (const InvalidValue& e) {
-        throw InvalidRecordType{static_cast<uint8_t>(e.asInt())};
+        throw InvalidRecordType{static_cast<std::uint8_t>(e.asInt())};
     }
 
     if (inputSize < recordSize)
@@ -97,9 +97,9 @@ std::size_t Record::read(std::istream& input, std::size_t inputSize)
     return recordSize;
 }
 
-uint8_t Record::calcPaddingLength() const
+std::uint8_t Record::calcPaddingLength() const
 {
-    auto result = static_cast<uint8_t>(8u - static_cast<uint8_t>(messageSize() % 8));
+    auto result = static_cast<std::uint8_t>(8u - static_cast<std::uint8_t>(messageSize() % 8));
     if (result == 8u)
         result = 0;
     return result;
diff --git a/src/record.h b/src/record.h
index 8ab8836..7966669 100644
--- a/src/record.h
+++ b/src/record.h
@@ -20,9 +20,9 @@ namespace fcgi {
 class Record {
 public:
     Record();
-    explicit Record(RecordType type, uint16_t requestId = 0);
+    explicit Record(RecordType type, std::uint16_t requestId = 0);
     template<typename TMessage>
-    Record(TMessage&& msg, uint16_t requestId)
+    Record(TMessage&& msg, std::uint16_t requestId)
         : type_(std::remove_reference_t<TMessage>::recordType)
         , requestId_(requestId)
         , message_(std::forward<TMessage>(msg))
@@ -30,7 +30,7 @@ class Record {
     }
 
     RecordType type() const;
-    uint16_t requestId() const;
+    std::uint16_t requestId() const;
     std::size_t size() const;
 
     void toStream(std::ostream& output) const;
@@ -49,11 +49,11 @@ class Record {
 
     void write(std::ostream& output) const;
     std::size_t read(std::istream& input, std::size_t inputSize);
-    uint8_t calcPaddingLength() const;
+    std::uint8_t calcPaddingLength() const;
 
 private:
     RecordType type_ = RecordType::UnknownType;
-    uint16_t requestId_ = 0;
+    std::uint16_t requestId_ = 0;
     std::variant<
             MsgAbortRequest,
             MsgBeginRequest,
diff --git a/src/recordreader.cpp b/src/recordreader.cpp
index 3a0c415..7d7dc45 100644
--- a/src/recordreader.cpp
+++ b/src/recordreader.cpp
@@ -6,7 +6,7 @@ namespace fcgi {
 
 RecordReader::RecordReader(
         std::function<void(Record&)> recordReadHandler,
-        std::function<void(uint8_t)> invalidRecordTypeHandler)
+        std::function<void(std::uint8_t)> invalidRecordTypeHandler)
     : recordReadHandler_{std::move(recordReadHandler)}
     , invalidRecordTypeHandler_{std::move(invalidRecordTypeHandler)}
 {
diff --git a/src/recordreader.h b/src/recordreader.h
index 6110eaa..1b9c45e 100644
--- a/src/recordreader.h
+++ b/src/recordreader.h
@@ -19,7 +19,7 @@ class RecordReader {
 public:
     explicit RecordReader(
             std::function<void(Record&)> recordReadHandler,
-            std::function<void(uint8_t)> invalidRecordTypeHandler = {});
+            std::function<void(std::uint8_t)> invalidRecordTypeHandler = {});
     void read(const char* data, std::size_t size);
     void setErrorInfoHandler(const std::function<void(const std::string&)>& errorInfoHandler);
 
@@ -32,7 +32,7 @@ class RecordReader {
 
 private:
     std::function<void(Record&)> recordReadHandler_;
-    std::function<void(uint8_t)> invalidRecordTypeHandler_;
+    std::function<void(std::uint8_t)> invalidRecordTypeHandler_;
     std::function<void(const std::string&)> errorInfoHandler_;
     DataReaderStream dataStream_;
     std::string leftover_;
diff --git a/src/requesterimpl.cpp b/src/requesterimpl.cpp
index d952cb6..9812cb7 100644
--- a/src/requesterimpl.cpp
+++ b/src/requesterimpl.cpp
@@ -9,11 +9,11 @@
 namespace fcgi {
 
 namespace {
-std::set<uint16_t> generateRequestIds(int maxRequestsNumber)
+std::set<std::uint16_t> generateRequestIds(int maxRequestsNumber)
 {
-    auto result = std::set<uint16_t>{};
+    auto result = std::set<std::uint16_t>{};
     for (auto i = 1; i <= maxRequestsNumber; ++i)
-        result.insert(static_cast<uint16_t>(i));
+        result.insert(static_cast<std::uint16_t>(i));
     return result;
 }
 
@@ -89,7 +89,7 @@ void RequesterImpl::initConnection(
                             keepConnection]() mutable
     {
         connectionState_ = ConnectionState::Connected;
-        requestIdPool_ = cfg_.multiplexingEnabled ? generateRequestIds(cfg_.maxRequestsNumber) : std::set<uint16_t>{1};
+        requestIdPool_ = cfg_.multiplexingEnabled ? generateRequestIds(cfg_.maxRequestsNumber) : std::set<std::uint16_t>{1};
         doSendRequest(params, data, responseHandler, keepConnection);
         *connectionOpeningRequestCancelHandler_ = *responseMap_.begin()->second.cancelRequestHandler;
     };
@@ -149,7 +149,7 @@ std::optional<RequestHandle> RequesterImpl::doSendRequest(
     return responseMap_.at(requestId).cancelRequestHandler;
 }
 
-void RequesterImpl::doEndRequest(uint16_t requestId, ResponseStatus responseStatus)
+void RequesterImpl::doEndRequest(std::uint16_t requestId, ResponseStatus responseStatus)
 {
     auto& responseContext = responseMap_.at(requestId);
     if (responseStatus == ResponseStatus::Successful)
@@ -165,16 +165,16 @@ void RequesterImpl::doEndRequest(uint16_t requestId, ResponseStatus responseStat
 }
 
 template<typename TMsg>
-void RequesterImpl::sendMessage(uint16_t requestId, TMsg&& msg)
+void RequesterImpl::sendMessage(std::uint16_t requestId, TMsg&& msg)
 {
     auto record = Record{std::forward<TMsg>(msg), requestId};
     sendRecord(record);
 }
-template void RequesterImpl::sendMessage<MsgGetValues>(uint16_t requestId, MsgGetValues&& msg);
-template void RequesterImpl::sendMessage<MsgBeginRequest>(uint16_t requestId, MsgBeginRequest&& msg);
-template void RequesterImpl::sendMessage<MsgAbortRequest>(uint16_t requestId, MsgAbortRequest&& msg);
-template void RequesterImpl::sendMessage<MsgParams>(uint16_t requestId, MsgParams&& msg);
-template void RequesterImpl::sendMessage<MsgStdIn>(uint16_t requestId, MsgStdIn&& msg);
+template void RequesterImpl::sendMessage<MsgGetValues>(std::uint16_t requestId, MsgGetValues&& msg);
+template void RequesterImpl::sendMessage<MsgBeginRequest>(std::uint16_t requestId, MsgBeginRequest&& msg);
+template void RequesterImpl::sendMessage<MsgAbortRequest>(std::uint16_t requestId, MsgAbortRequest&& msg);
+template void RequesterImpl::sendMessage<MsgParams>(std::uint16_t requestId, MsgParams&& msg);
+template void RequesterImpl::sendMessage<MsgStdIn>(std::uint16_t requestId, MsgStdIn&& msg);
 
 void RequesterImpl::sendRecord(const Record& record)
 {
@@ -264,13 +264,13 @@ void RequesterImpl::onGetValuesResult(const MsgGetValuesResult& msg)
     onConnectionSuccess_();
 }
 
-void RequesterImpl::onUnknownType(uint16_t requestId, const MsgUnknownType& msg)
+void RequesterImpl::onUnknownType(std::uint16_t requestId, const MsgUnknownType& msg)
 {
     notifyAboutError("Received unknown record type: " + std::to_string(msg.unknownTypeValue()));
     sendMessage(requestId, MsgAbortRequest{});
 }
 
-void RequesterImpl::onEndRequest(uint16_t requestId, const MsgEndRequest& msg)
+void RequesterImpl::onEndRequest(std::uint16_t requestId, const MsgEndRequest& msg)
 {
     doEndRequest(
             requestId,
@@ -278,12 +278,12 @@ void RequesterImpl::onEndRequest(uint16_t requestId, const MsgEndRequest& msg)
                                                                     : ResponseStatus::Failed);
 }
 
-void RequesterImpl::onStdOut(uint16_t requestId, const MsgStdOut& msg)
+void RequesterImpl::onStdOut(std::uint16_t requestId, const MsgStdOut& msg)
 {
     responseMap_.at(requestId).responseData.data += msg.data();
 }
 
-void RequesterImpl::onStdErr(uint16_t requestId, const MsgStdErr& msg)
+void RequesterImpl::onStdErr(std::uint16_t requestId, const MsgStdErr& msg)
 {
     responseMap_.at(requestId).responseData.errorMsg += msg.data();
 }
diff --git a/src/requesterimpl.h b/src/requesterimpl.h
index 21277eb..6d64965 100644
--- a/src/requesterimpl.h
+++ b/src/requesterimpl.h
@@ -59,18 +59,18 @@ class RequesterImpl {
             const std::string& data,
             std::function<void(std::optional<ResponseData>)> responseHandler,
             bool keepConnection);
-    void doEndRequest(uint16_t requestId, ResponseStatus responseStatus);
+    void doEndRequest(std::uint16_t requestId, ResponseStatus responseStatus);
     void onRecordRead(const Record& record);
     template<typename TMsg>
-    void sendMessage(uint16_t requestId, TMsg&& msg);
+    void sendMessage(std::uint16_t requestId, TMsg&& msg);
     void notifyAboutError(const std::string& errorMsg);
     void sendRecord(const Record& record);
     bool isRecordExpected(const Record& record);
     void onGetValuesResult(const MsgGetValuesResult& msg);
-    void onUnknownType(uint16_t requestId, const MsgUnknownType& msg);
-    void onEndRequest(uint16_t requestId, const MsgEndRequest& msg);
-    void onStdOut(uint16_t requestId, const MsgStdOut& msg);
-    void onStdErr(uint16_t requestId, const MsgStdErr& msg);
+    void onUnknownType(std::uint16_t requestId, const MsgUnknownType& msg);
+    void onEndRequest(std::uint16_t requestId, const MsgEndRequest& msg);
+    void onStdOut(std::uint16_t requestId, const MsgStdOut& msg);
+    void onStdErr(std::uint16_t requestId, const MsgStdErr& msg);
 
 private:
     struct Config {
@@ -93,8 +93,8 @@ class RequesterImpl {
     std::function<void()> onConnectionSuccess_;
     std::shared_ptr<std::function<void()>> connectionOpeningRequestCancelHandler_;
     ConnectionState connectionState_ = ConnectionState::NotConnected;
-    std::set<uint16_t> requestIdPool_;
-    std::map<uint16_t, ResponseContext> responseMap_;
+    std::set<std::uint16_t> requestIdPool_;
+    std::map<std::uint16_t, ResponseContext> responseMap_;
     std::function<void(const std::string&)> sendData_;
     std::function<void()> disconnect_;
 };
diff --git a/src/responderimpl.cpp b/src/responderimpl.cpp
index ee97627..5a20034 100644
--- a/src/responderimpl.cpp
+++ b/src/responderimpl.cpp
@@ -25,7 +25,7 @@ ResponderImpl::ResponderImpl(
               {
                   onRecordRead(record);
               },
-              [this](uint8_t recordType)
+              [this](std::uint8_t recordType)
               {
                   sendMessage(0, MsgUnknownType{recordType});
               }}
@@ -34,7 +34,7 @@ ResponderImpl::ResponderImpl(
     , disconnect_{std::move(disconnect)}
     , processRequest_{std::move(processRequest)}
     , responseSender_{std::make_shared<ResponseSender>(
-              [this](uint16_t id, std::string&& data, std::string&& errorMsg)
+              [this](std::uint16_t id, std::string&& data, std::string&& errorMsg)
               {
                   sendResponse(id, std::move(data), std::move(errorMsg));
               })}
@@ -42,14 +42,14 @@ ResponderImpl::ResponderImpl(
 }
 
 template<typename TMsg>
-void ResponderImpl::sendMessage(uint16_t requestId, TMsg&& msg)
+void ResponderImpl::sendMessage(std::uint16_t requestId, TMsg&& msg)
 {
     auto record = Record{std::forward<TMsg>(msg), requestId};
     sendRecord(record);
 }
-template void ResponderImpl::sendMessage<MsgUnknownType>(uint16_t requestId, MsgUnknownType&& msg);
-template void ResponderImpl::sendMessage<MsgEndRequest>(uint16_t requestId, MsgEndRequest&& msg);
-template void ResponderImpl::sendMessage<MsgGetValuesResult>(uint16_t requestId, MsgGetValuesResult&& msg);
+template void ResponderImpl::sendMessage<MsgUnknownType>(std::uint16_t requestId, MsgUnknownType&& msg);
+template void ResponderImpl::sendMessage<MsgEndRequest>(std::uint16_t requestId, MsgEndRequest&& msg);
+template void ResponderImpl::sendMessage<MsgGetValuesResult>(std::uint16_t requestId, MsgGetValuesResult&& msg);
 
 void ResponderImpl::receiveData(const char* data, std::size_t size)
 {
@@ -85,7 +85,7 @@ void ResponderImpl::onRecordRead(const Record& record)
     }
 }
 
-void ResponderImpl::onBeginRequest(uint16_t requestId, const MsgBeginRequest& msg)
+void ResponderImpl::onBeginRequest(std::uint16_t requestId, const MsgBeginRequest& msg)
 {
     if (msg.role() != Role::Responder) {
         sendMessage(requestId, MsgEndRequest{0, ProtocolStatus::UnknownRole});
@@ -109,7 +109,7 @@ void ResponderImpl::onBeginRequest(uint16_t requestId, const MsgBeginRequest& ms
     createRequest(requestId, msg.resultConnectionState() == ResultConnectionState::KeepOpen);
 }
 
-void ResponderImpl::endRequest(uint16_t requestId)
+void ResponderImpl::endRequest(std::uint16_t requestId)
 {
     sendMessage(requestId, MsgEndRequest{0, ProtocolStatus::RequestComplete});
     if (!requestRegistry_.at(requestId).keepConnection())
@@ -118,12 +118,12 @@ void ResponderImpl::endRequest(uint16_t requestId)
     deleteRequest(requestId);
 }
 
-void ResponderImpl::createRequest(uint16_t requestId, bool keepConnection)
+void ResponderImpl::createRequest(std::uint16_t requestId, bool keepConnection)
 {
     requestRegistry_.emplace(requestId, RequestData{keepConnection});
 }
 
-void ResponderImpl::deleteRequest(uint16_t requestId)
+void ResponderImpl::deleteRequest(std::uint16_t requestId)
 {
     requestRegistry_.erase(requestId);
 }
@@ -147,12 +147,12 @@ void ResponderImpl::onGetValues(const MsgGetValues& msg)
     sendMessage(0, std::move(result));
 }
 
-void ResponderImpl::onParams(uint16_t requestId, const MsgParams& msg)
+void ResponderImpl::onParams(std::uint16_t requestId, const MsgParams& msg)
 {
     requestRegistry_.at(requestId).addMessage(msg);
 }
 
-void ResponderImpl::onStdIn(uint16_t requestId, const MsgStdIn& msg)
+void ResponderImpl::onStdIn(std::uint16_t requestId, const MsgStdIn& msg)
 {
     requestRegistry_.at(requestId).addMessage(msg);
     if (msg.data().empty())
@@ -184,7 +184,7 @@ bool ResponderImpl::isRecordExpected(const Record& record)
     return false;
 }
 
-void ResponderImpl::onRequestReceived(uint16_t requestId)
+void ResponderImpl::onRequestReceived(std::uint16_t requestId)
 {
     auto request = requestRegistry_.at(requestId).makeRequest();
     if (!request)
@@ -201,7 +201,7 @@ void ResponderImpl::onRequestReceived(uint16_t requestId)
                      }});
 }
 
-void ResponderImpl::sendResponse(uint16_t id, std::string&& data, std::string&& errorMsg)
+void ResponderImpl::sendResponse(std::uint16_t id, std::string&& data, std::string&& errorMsg)
 {
     auto dataStream = makeStream<MsgStdOut>(id, data);
     auto errorStream = makeStream<MsgStdErr>(id, errorMsg);
diff --git a/src/responderimpl.h b/src/responderimpl.h
index f1119ec..8702350 100644
--- a/src/responderimpl.h
+++ b/src/responderimpl.h
@@ -34,20 +34,20 @@ class ResponderImpl {
 
 private:
     void onRecordRead(const Record& record);
-    void onBeginRequest(uint16_t requestId, const MsgBeginRequest& msg);
+    void onBeginRequest(std::uint16_t requestId, const MsgBeginRequest& msg);
     void onGetValues(const MsgGetValues& msg);
-    void onParams(uint16_t requestId, const MsgParams& msg);
-    void onStdIn(uint16_t requestId, const StreamDataMessage<RecordType::StdIn>& msg);
-    void onRequestReceived(uint16_t requestId);
+    void onParams(std::uint16_t requestId, const MsgParams& msg);
+    void onStdIn(std::uint16_t requestId, const StreamDataMessage<RecordType::StdIn>& msg);
+    void onRequestReceived(std::uint16_t requestId);
     void sendRecord(const Record& record);
-    void sendResponse(uint16_t id, std::string&& data, std::string&& errorMsg);
+    void sendResponse(std::uint16_t id, std::string&& data, std::string&& errorMsg);
 
     bool isRecordExpected(const Record& record);
-    void endRequest(uint16_t requestId);
+    void endRequest(std::uint16_t requestId);
 
     void notifyAboutError(const std::string& errorMsg);
-    void createRequest(uint16_t requestId, bool keepConnection);
-    void deleteRequest(uint16_t requestId);
+    void createRequest(std::uint16_t requestId, bool keepConnection);
+    void deleteRequest(std::uint16_t requestId);
 
 private:
     struct Config {
@@ -57,19 +57,19 @@ class ResponderImpl {
     } cfg_;
 
     RecordReader recordReader_;
-    std::unordered_map<uint16_t, RequestData> requestRegistry_;
+    std::unordered_map<std::uint16_t, RequestData> requestRegistry_;
     std::function<void(const std::string&)> errorInfoHandler_;
     DataWriterStream recordStream_;
     std::function<void(const std::string&)> sendData_;
     std::function<void()> disconnect_;
     std::function<void(Request&& request, Response&& response)> processRequest_;
 
-    using ResponseSender = std::function<void(uint16_t, std::string&&, std::string&&)>;
+    using ResponseSender = std::function<void(std::uint16_t, std::string&&, std::string&&)>;
     std::shared_ptr<ResponseSender> responseSender_;
 
 private:
     template<typename TMsg>
-    void sendMessage(uint16_t requestId, TMsg&& msg);
+    void sendMessage(std::uint16_t requestId, TMsg&& msg);
 };
 
 } // namespace fcgi
diff --git a/src/streammaker.h b/src/streammaker.h
index dca3330..dc3a516 100644
--- a/src/streammaker.h
+++ b/src/streammaker.h
@@ -9,7 +9,7 @@ namespace fcgi {
 
 template<typename TMsg>
 std::vector<Record> makeStream(
-        uint16_t requestId,
+        std::uint16_t requestId,
         std::string_view data,
         std::size_t maxDataMessageSize = hardcoded::maxDataMessageSize)
 {
diff --git a/src/types.h b/src/types.h
index 7387e78..25f175c 100644
--- a/src/types.h
+++ b/src/types.h
@@ -5,7 +5,7 @@
 
 namespace fcgi {
 
-enum class RecordType : uint8_t {
+enum class RecordType : std::uint8_t {
     BeginRequest = 1,
     AbortRequest = 2,
     EndRequest = 3,
@@ -19,23 +19,23 @@ enum class RecordType : uint8_t {
     UnknownType = 11,
 };
 
-inline RecordType recordTypeFromInt(uint8_t val)
+inline RecordType recordTypeFromInt(std::uint8_t val)
 {
-    if (val < static_cast<uint8_t>(RecordType::BeginRequest) || val > static_cast<uint8_t>(RecordType::UnknownType))
+    if (val < static_cast<std::uint8_t>(RecordType::BeginRequest) || val > static_cast<std::uint8_t>(RecordType::UnknownType))
         throw InvalidValue(InvalidValueType::RecordType, val);
     else
         return static_cast<RecordType>(val);
 }
 
-enum class Role : uint16_t {
+enum class Role : std::uint16_t {
     Responder = 1,
     Authorizer = 2,
     Filter = 3,
 };
 
-inline Role roleFromInt(uint16_t val)
+inline Role roleFromInt(std::uint16_t val)
 {
-    if (val < static_cast<uint16_t>(Role::Responder) || val > static_cast<uint16_t>(Role::Filter))
+    if (val < static_cast<std::uint16_t>(Role::Responder) || val > static_cast<std::uint16_t>(Role::Filter))
         throw InvalidValue(InvalidValueType::Role, val);
     else
         return static_cast<Role>(val);
@@ -46,16 +46,16 @@ enum class ResultConnectionState {
     KeepOpen = 1
 };
 
-enum class ProtocolStatus : uint8_t {
+enum class ProtocolStatus : std::uint8_t {
     RequestComplete = 0,
     CantMpxConn = 1,
     Overloaded = 2,
     UnknownRole = 3,
 };
 
-inline ProtocolStatus protocolStatusFromInt(uint8_t val)
+inline ProtocolStatus protocolStatusFromInt(std::uint8_t val)
 {
-    if (val > static_cast<uint8_t>(ProtocolStatus::UnknownRole))
+    if (val > static_cast<std::uint8_t>(ProtocolStatus::UnknownRole))
         throw InvalidValue(InvalidValueType::ProtocolStatus, val);
     else
         return static_cast<ProtocolStatus>(val);
diff --git a/tests/test_record_serialization.cpp b/tests/test_record_serialization.cpp
index 48ce827..972ba5b 100644
--- a/tests/test_record_serialization.cpp
+++ b/tests/test_record_serialization.cpp
@@ -175,7 +175,7 @@ TEST(RecordSerializationError, MsgBeginRequestInvalidRole)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint16_t>(99) << static_cast<uint8_t>(1);
+    encoder << static_cast<std::uint16_t>(99) << static_cast<std::uint8_t>(1);
     encoder.addPadding(5);
 
     auto msgData = output.str();
@@ -198,7 +198,7 @@ TEST(RecordSerializationError, MsgBeginRequestCutoffInput)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint16_t>(fcgi::Role::Responder) << static_cast<uint8_t>(1);
+    encoder << static_cast<std::uint16_t>(fcgi::Role::Responder) << static_cast<std::uint8_t>(1);
     encoder.addPadding(4); //should be 5
 
     auto msgData = output.str();
@@ -216,7 +216,7 @@ TEST(RecordSerializationError, MsgEndRequestCutoffInput)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint32_t>(0) << static_cast<uint8_t>(0);
+    encoder << static_cast<std::uint32_t>(0) << static_cast<std::uint8_t>(0);
     encoder.addPadding(2); //should be 3
 
     auto msgData = output.str();
@@ -397,7 +397,7 @@ TEST(RecordSerializationError, MsgUnkownTypeCutoffInput)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint8_t>(0);
+    encoder << static_cast<std::uint8_t>(0);
     encoder.addPadding(6); //should be 7
 
     auto msgData = output.str();
@@ -433,9 +433,9 @@ TEST(RecordSerializationError, RecordUsupportedProtocolVersion)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint8_t>(10) // wrong protocol version
-            << static_cast<uint8_t>(fcgi::RecordType::AbortRequest) << static_cast<uint16_t>(1)
-            << static_cast<uint16_t>(0) << static_cast<uint8_t>(0);
+    encoder << static_cast<std::uint8_t>(10) // wrong protocol version
+            << static_cast<std::uint8_t>(fcgi::RecordType::AbortRequest) << static_cast<std::uint16_t>(1)
+            << static_cast<std::uint16_t>(0) << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
 
     auto recordData = output.str();
@@ -457,8 +457,8 @@ TEST(RecordSerializationError, RecordInvalidType)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint8_t>(1) << static_cast<uint8_t>(99) // wrong record type
-            << static_cast<uint16_t>(1) << static_cast<uint16_t>(0) << static_cast<uint8_t>(0);
+    encoder << static_cast<std::uint8_t>(1) << static_cast<std::uint8_t>(99) // wrong record type
+            << static_cast<std::uint16_t>(1) << static_cast<std::uint16_t>(0) << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
 
     auto recordData = output.str();
@@ -480,13 +480,13 @@ TEST(RecordSerializationError, RecordInvalidMessageReadError)
 {
     auto output = std::ostringstream{};
     auto encoder = fcgi::Encoder(output);
-    encoder << static_cast<uint8_t>(1) << static_cast<uint8_t>(fcgi::RecordType::BeginRequest)
-            << static_cast<uint16_t>(1) << static_cast<uint16_t>(8) //message size
-            << static_cast<uint8_t>(0);
+    encoder << static_cast<std::uint8_t>(1) << static_cast<std::uint8_t>(fcgi::RecordType::BeginRequest)
+            << static_cast<std::uint16_t>(1) << static_cast<std::uint16_t>(8) //message size
+            << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     //MsgBeginRequest
-    encoder << static_cast<uint16_t>(99) // wrong role
-            << static_cast<uint8_t>(1);
+    encoder << static_cast<std::uint16_t>(99) // wrong role
+            << static_cast<std::uint8_t>(1);
     encoder.addPadding(5);
 
     auto recordData = output.str();
diff --git a/tests/test_requester.cpp b/tests/test_requester.cpp
index baa3cea..1588f0e 100644
--- a/tests/test_requester.cpp
+++ b/tests/test_requester.cpp
@@ -74,7 +74,7 @@ class TestRequester : public TestWithParam<bool> {
         requester_.receive(data);
     }
     template<typename TMsg, std::enable_if_t<!std::is_convertible_v<TMsg, std::string>>* = nullptr>
-    void receiveMessage(TMsg&& msg, uint16_t requestId = 0)
+    void receiveMessage(TMsg&& msg, std::uint16_t requestId = 0)
     {
         requester_.receive(messageData(std::forward<TMsg>(msg), requestId));
     }
@@ -83,7 +83,7 @@ class TestRequester : public TestWithParam<bool> {
         requester_.receive(recordData);
     }
     template<typename TMsg>
-    void expectMessageToBeSent(TMsg&& msg, uint16_t requestId = 0)
+    void expectMessageToBeSent(TMsg&& msg, std::uint16_t requestId = 0)
     {
         EXPECT_CALL(requester_, sendData(messageData(std::forward<TMsg>(msg), requestId)));
     }
@@ -114,7 +114,7 @@ class TestRequester : public TestWithParam<bool> {
     std::optional<fcgi::RequestHandle> makeRequest(
             const std::map<std::string, std::string>& fcgiParams,
             const std::string& fcgiData,
-            uint16_t requestId = 1,
+            std::uint16_t requestId = 1,
             int maxRequestsNumber = 10,
             bool isMultiplexingEnabled = true)
     {
diff --git a/tests/test_responder.cpp b/tests/test_responder.cpp
index 1b05c7d..c8aedca 100644
--- a/tests/test_responder.cpp
+++ b/tests/test_responder.cpp
@@ -89,7 +89,7 @@ class BaseTestResponder : public ::testing::TestWithParam<bool> {
         responder_.receive(data);
     }
     template<typename TMsg, std::enable_if_t<!std::is_convertible_v<TMsg, std::string>>* = nullptr>
-    void receiveMessage(TMsg&& msg, uint16_t requestId = 0)
+    void receiveMessage(TMsg&& msg, std::uint16_t requestId = 0)
     {
         responder_.receive(messageData(std::forward<TMsg>(msg), requestId));
     }
@@ -98,7 +98,7 @@ class BaseTestResponder : public ::testing::TestWithParam<bool> {
         responder_.receive(recordData);
     }
     template<typename TMsg>
-    void expectMessageToBeSent(TMsg&& msg, uint16_t requestId = 0)
+    void expectMessageToBeSent(TMsg&& msg, std::uint16_t requestId = 0)
     {
         EXPECT_CALL(responder_, sendData(messageData(std::forward<TMsg>(msg), requestId)));
     }
@@ -133,8 +133,8 @@ TEST_F(TestResponder, UnknownType)
 
     auto output = std::ostringstream{};
     auto encoder = Encoder(output);
-    encoder << hardcoded::protocolVersion << static_cast<uint8_t>(99) << static_cast<uint16_t>(1)
-            << static_cast<uint16_t>(0) << static_cast<uint8_t>(0);
+    encoder << hardcoded::protocolVersion << static_cast<std::uint8_t>(99) << static_cast<std::uint16_t>(1)
+            << static_cast<std::uint16_t>(0) << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     receiveMessage(output.str());
     EXPECT_EQ(errorInfo_, "Record type \"99\" is invalid.\n");
@@ -242,7 +242,7 @@ TEST_P(TestResponder, ReceivingMessagesInLargeChunks)
     auto streamRecordData = std::string(hardcoded::maxDataMessageSize, '0');
     auto streamData = std::string{};
     auto expectedRequestData = std::string{};
-    auto requestId = static_cast<uint16_t>(1);
+    auto requestId = static_cast<std::uint16_t>(1);
     for (auto i = 0; i < 3; ++i) {
         auto inStream = MsgStdIn{streamRecordData};
         expectedRequestData += inStream.data();
@@ -337,14 +337,14 @@ TEST_P(TestResponder, RecordReadError)
     auto output = std::ostringstream{};
     auto encoder = Encoder{output};
     auto nameValue = fcgi::NameValue{"wrongName", "0"};
-    encoder << hardcoded::protocolVersion << static_cast<uint8_t>(RecordType::GetValues) << static_cast<uint16_t>(1)
-            << static_cast<uint16_t>(nameValue.size()) << static_cast<uint8_t>(0);
+    encoder << hardcoded::protocolVersion << static_cast<std::uint8_t>(RecordType::GetValues) << static_cast<std::uint16_t>(1)
+            << static_cast<std::uint16_t>(nameValue.size()) << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     nameValue.toStream(output);
 
     auto receivedData = output.str();
-    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<uint16_t>(1));
-    receivedData += messageData(MsgAbortRequest{}, static_cast<uint16_t>(1));
+    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<std::uint16_t>(1));
+    receivedData += messageData(MsgAbortRequest{}, static_cast<std::uint16_t>(1));
     receiveMessage(receivedData);
 
     EXPECT_EQ(errorInfo_, "Record message read error: Value request value \"wrongName\" is invalid.\n");
@@ -356,15 +356,15 @@ TEST_P(TestResponder, RecordReadErrorMisalignedNameValue)
     auto output = std::ostringstream{};
     auto encoder = Encoder{output};
     auto nameValue = fcgi::NameValue{"FCGI_MAX_CONNS", ""};
-    encoder << hardcoded::protocolVersion << static_cast<uint8_t>(RecordType::GetValues) << static_cast<uint16_t>(1)
-            << static_cast<uint16_t>(nameValue.size() - 1) //wrong size
-            << static_cast<uint8_t>(0);
+    encoder << hardcoded::protocolVersion << static_cast<std::uint8_t>(RecordType::GetValues) << static_cast<std::uint16_t>(1)
+            << static_cast<std::uint16_t>(nameValue.size() - 1) //wrong size
+            << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     nameValue.toStream(output);
 
     auto receivedData = output.str();
-    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<uint16_t>(1));
-    receivedData += messageData(MsgAbortRequest{}, static_cast<uint16_t>(1));
+    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<std::uint16_t>(1));
+    receivedData += messageData(MsgAbortRequest{}, static_cast<std::uint16_t>(1));
     receiveMessage(receivedData);
     EXPECT_EQ(
             errorInfo_,
diff --git a/utils/fuzz_input_generator/input_generating_test_responder.cpp b/utils/fuzz_input_generator/input_generating_test_responder.cpp
index d07ac82..1cf7b28 100644
--- a/utils/fuzz_input_generator/input_generating_test_responder.cpp
+++ b/utils/fuzz_input_generator/input_generating_test_responder.cpp
@@ -12,6 +12,7 @@
 #include <constants.h>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <cstdint>
 #include <fstream>
 #include <filesystem>
 
@@ -97,7 +98,7 @@ class BaseTestResponder : public ::testing::TestWithParam<bool>{
         responder_.receive(data);
     }
     template <typename TMsg, std::enable_if_t<!std::is_convertible_v<TMsg, std::string>>* = nullptr>
-    void receiveMessage(TMsg&& msg, uint16_t requestId = 0)
+    void receiveMessage(TMsg&& msg, std::uint16_t requestId = 0)
     {
         auto message = messageData(std::forward<TMsg>(msg), requestId);
         createUnitTestInputDataFile(message);
@@ -109,7 +110,7 @@ class BaseTestResponder : public ::testing::TestWithParam<bool>{
         responder_.receive(recordData);
     }
     template <typename TMsg>
-    void expectMessageToBeSent(TMsg&& msg, uint16_t requestId = 0)
+    void expectMessageToBeSent(TMsg&& msg, std::uint16_t requestId = 0)
     {
         EXPECT_CALL(responder_, sendData(messageData(std::forward<TMsg>(msg), requestId)));
     }
@@ -146,10 +147,10 @@ TEST_F(TestResponder, UnknownType)
     auto output = std::ostringstream{};
     auto encoder = Encoder(output);
     encoder  << hardcoded::protocolVersion
-             << static_cast<uint8_t>(99)
-             << static_cast<uint16_t>(1)
-             << static_cast<uint16_t>(0)
-             << static_cast<uint8_t>(0);
+             << static_cast<std::uint8_t>(99)
+             << static_cast<std::uint16_t>(1)
+             << static_cast<std::uint16_t>(0)
+             << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     receiveMessage(output.str());
     EXPECT_EQ(errorInfo_, "Record type \"99\" is invalid.\n");
@@ -258,7 +259,7 @@ TEST_F(TestResponder, ReceivingMessagesInLargeChunks)
     auto streamRecordData = std::string(hardcoded::maxDataMessageSize, '0');
     auto streamData = std::string{};
     auto expectedRequestData = std::string{};
-    auto requestId = static_cast<uint16_t>(1);
+    auto requestId = static_cast<std::uint16_t>(1);
     for (auto i = 0; i < 3; ++i){
         auto inStream = MsgStdIn{streamRecordData};
         expectedRequestData += inStream.data();
@@ -354,16 +355,16 @@ TEST_F(TestResponder, RecordMessageReadError)
     auto encoder = Encoder{output};
     auto nameValue = fcgi::NameValue{"wrongName", "0"};
     encoder  << hardcoded::protocolVersion
-             << static_cast<uint8_t>(RecordType::GetValues)
-             << static_cast<uint16_t>(1)
-             << static_cast<uint16_t>(nameValue.size())
-             << static_cast<uint8_t>(0);
+             << static_cast<std::uint8_t>(RecordType::GetValues)
+             << static_cast<std::uint16_t>(1)
+             << static_cast<std::uint16_t>(nameValue.size())
+             << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     nameValue.toStream(output);
 
     auto receivedData = output.str();
-    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<uint16_t>(1));
-    receivedData += messageData(MsgAbortRequest{}, static_cast<uint16_t>(1));
+    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<std::uint16_t>(1));
+    receivedData += messageData(MsgAbortRequest{}, static_cast<std::uint16_t>(1));
     receiveMessage(receivedData);
 
     EXPECT_EQ(errorInfo_, "Record message read error: Value request value \"wrongName\" is invalid.\n");
@@ -376,16 +377,16 @@ TEST_F(TestResponder, RecordReadErrorMisalignedNameValue)
     auto encoder = Encoder{output};
     auto nameValue = fcgi::NameValue{"FCGI_MAX_CONNS", ""};
     encoder  << hardcoded::protocolVersion
-             << static_cast<uint8_t>(RecordType::GetValues)
-             << static_cast<uint16_t>(1)
-             << static_cast<uint16_t>(nameValue.size() - 1) //wrong size
-             << static_cast<uint8_t>(0);
+             << static_cast<std::uint8_t>(RecordType::GetValues)
+             << static_cast<std::uint16_t>(1)
+             << static_cast<std::uint16_t>(nameValue.size() - 1) //wrong size
+             << static_cast<std::uint8_t>(0);
     encoder.addPadding(1);
     nameValue.toStream(output);
 
     auto receivedData = output.str();
-    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<uint16_t>(1));
-    receivedData += messageData(MsgAbortRequest{}, static_cast<uint16_t>(1));
+    receivedData += messageData(MsgBeginRequest{Role::Responder, resultConnectionState()}, static_cast<std::uint16_t>(1));
+    receivedData += messageData(MsgAbortRequest{}, static_cast<std::uint16_t>(1));
     receiveMessage(receivedData);
     EXPECT_EQ(errorInfo_, "Record message read error: Misaligned name-value\nProtocol version \"83\" isn't supported.\n");
 }