Implementing kafka produce messages

18 files changed, 7372 insertions, 0 deletions

diff --git a/ydb/core/CMakeLists.txt b/ydb/core/CMakeLists.txt
index 6f3ca338f1b..7e953aaa5d9 100644
--- a/ydb/core/CMakeLists.txt
+++ b/ydb/core/CMakeLists.txt
@@ -32,6 +32,7 @@ add_subdirectory(grpc_streaming)
 add_subdirectory(health_check)
 add_subdirectory(http_proxy)
 add_subdirectory(io_formats)
+add_subdirectory(kafkaproxy)
 add_subdirectory(kesus)
 add_subdirectory(keyvalue)
 add_subdirectory(kqp)
diff --git a/ydb/core/kafkaproxy/CMakeLists.darwin-x86_64.txt b/ydb/core/kafkaproxy/CMakeLists.darwin-x86_64.txt
new file mode 100644
index 00000000000..3e701fd2461
--- /dev/null
+++ b/ydb/core/kafkaproxy/CMakeLists.darwin-x86_64.txt
@@ -0,0 +1,23 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+add_subdirectory(ut)
+
+add_library(ydb-core-kafkaproxy)
+target_link_libraries(ydb-core-kafkaproxy PUBLIC
+  contrib-libs-cxxsupp
+  yutil
+  cpp-actors-core
+  cpp-actors-protos
+  ydb-core-base
+  ydb-core-protos
+)
+target_sources(ydb-core-kafkaproxy PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages_int.cpp
+)
diff --git a/ydb/core/kafkaproxy/CMakeLists.linux-aarch64.txt b/ydb/core/kafkaproxy/CMakeLists.linux-aarch64.txt
new file mode 100644
index 00000000000..59a73cf06e1
--- /dev/null
+++ b/ydb/core/kafkaproxy/CMakeLists.linux-aarch64.txt
@@ -0,0 +1,24 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+add_subdirectory(ut)
+
+add_library(ydb-core-kafkaproxy)
+target_link_libraries(ydb-core-kafkaproxy PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+  yutil
+  cpp-actors-core
+  cpp-actors-protos
+  ydb-core-base
+  ydb-core-protos
+)
+target_sources(ydb-core-kafkaproxy PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages_int.cpp
+)
diff --git a/ydb/core/kafkaproxy/CMakeLists.linux-x86_64.txt b/ydb/core/kafkaproxy/CMakeLists.linux-x86_64.txt
new file mode 100644
index 00000000000..59a73cf06e1
--- /dev/null
+++ b/ydb/core/kafkaproxy/CMakeLists.linux-x86_64.txt
@@ -0,0 +1,24 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+add_subdirectory(ut)
+
+add_library(ydb-core-kafkaproxy)
+target_link_libraries(ydb-core-kafkaproxy PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+  yutil
+  cpp-actors-core
+  cpp-actors-protos
+  ydb-core-base
+  ydb-core-protos
+)
+target_sources(ydb-core-kafkaproxy PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages_int.cpp
+)
diff --git a/ydb/core/kafkaproxy/CMakeLists.txt b/ydb/core/kafkaproxy/CMakeLists.txt
new file mode 100644
index 00000000000..f8b31df0c11
--- /dev/null
+++ b/ydb/core/kafkaproxy/CMakeLists.txt
@@ -0,0 +1,17 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-aarch64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+  include(CMakeLists.darwin-x86_64.txt)
+elseif (WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL "AMD64" AND NOT HAVE_CUDA)
+  include(CMakeLists.windows-x86_64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-x86_64.txt)
+endif()
diff --git a/ydb/core/kafkaproxy/CMakeLists.windows-x86_64.txt b/ydb/core/kafkaproxy/CMakeLists.windows-x86_64.txt
new file mode 100644
index 00000000000..3e701fd2461
--- /dev/null
+++ b/ydb/core/kafkaproxy/CMakeLists.windows-x86_64.txt
@@ -0,0 +1,23 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+add_subdirectory(ut)
+
+add_library(ydb-core-kafkaproxy)
+target_link_libraries(ydb-core-kafkaproxy PUBLIC
+  contrib-libs-cxxsupp
+  yutil
+  cpp-actors-core
+  cpp-actors-protos
+  ydb-core-base
+  ydb-core-protos
+)
+target_sources(ydb-core-kafkaproxy PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/kafka_messages_int.cpp
+)
diff --git a/ydb/core/kafkaproxy/kafka.h b/ydb/core/kafkaproxy/kafka.h
new file mode 100644
index 00000000000..b7d1ade2257
--- /dev/null
+++ b/ydb/core/kafkaproxy/kafka.h
@@ -0,0 +1,138 @@
+#pragma once
+
+#include <istream>
+#include <ostream>
+
+namespace NKafka {
+
+/*
+ * There are four versions of each field:
+ * - present version   - field serialized and deserialized for this version of protocol.
+ * - nullable version - field can be null for this versions of protocol. Default field isn't nullable.
+ * - flexible version - field write as map item tag->value (or tagged version)
+ * - message flexaible version - version of message support tags
+ *
+ * Fields may be of type:
+ * - bool    - fixed length=1
+ * - int8    - fixed length=1
+ * - int16   - fixed length=2
+ * - uint16  - fixed length=2
+ * - int32   - fixed length=4
+ * - uint32  - fixed length=4
+ * - int64   - fixed length=8
+ * - uuid    - fixed length=16
+ * - float64 - fixed length=8
+ * - string  - can be nullable
+ * - bytes   - can be nullable
+ * - records - can be nullable
+ * - struct
+ * - array   - can be nullable
+ */
+
+using TKafkaBool = ui8;
+using TKafkaInt8 = i8;
+using TKafkaInt16 = i16;
+using TKafkaUint16 = ui16;
+using TKafkaInt32 = i32;
+using TKafkaUint32 = ui32;
+using TKafkaInt64 = i64;
+using TKafkaUuid = NYql::TWide<ui64>;
+using TKafkaFloat64 = double;
+using TKafkaRawString = TString;
+using TKafkaString = std::optional<TKafkaRawString>;
+using TKafkaRawBytes = TBuffer;
+using TKafkaBytes = std::optional<TKafkaRawBytes>;
+using TKafkaRecords = std::optional<TKafkaRawBytes>;
+
+
+using TKafkaVersion = i16;
+
+void ErrorOnUnexpectedEnd(std::istream& is);
+
+class TKafkaWritable {
+public:
+    TKafkaWritable(std::ostream& os) : Os(os) {};
+
+    template<typename T>
+    TKafkaWritable& operator<<(const T val) {
+        char* v = (char*)&val;
+#ifdef WORDS_BIGENDIAN
+        Os.write(v, sizeof(T));
+#else
+        for(i8 i = sizeof(T) - 1; 0 <= i; --i) {
+            Os.write(v + i, sizeof(char));
+        }
+#endif
+        return *this;
+    };
+
+    TKafkaWritable& operator<<(const TKafkaUuid& val);
+    TKafkaWritable& operator<<(const TKafkaRawBytes& val);
+    TKafkaWritable& operator<<(const TKafkaRawString& val);
+
+    void writeUnsignedVarint(TKafkaUint32 val);
+    void writeVarint(TKafkaInt32 val);
+    void writeVarint(TKafkaInt64 val);
+
+private:
+    std::ostream& Os;
+};
+
+class TKafkaReadable {
+public:
+    TKafkaReadable(std::istream& is): Is(is) {};
+
+    template<typename T>
+    TKafkaReadable& operator>>(T& val) {
+        char* v = (char*)&val;
+#ifdef WORDS_BIGENDIAN
+        Is.read(v, sizeof(T));
+#else
+        for(i8 i = sizeof(T) - 1; 0 <= i; --i) {
+            Is.read(v + i, sizeof(char));
+        }
+#endif
+        ErrorOnUnexpectedEnd(Is);
+        return *this;
+    };
+
+    TKafkaReadable& operator>>(TKafkaUuid& val);
+
+    void read(char* val, int length);
+    ui32 readUnsignedVarint();
+
+    void skip(int length);
+
+private:
+    std::istream& Is;
+};
+
+
+class TMessage {
+public:
+    virtual ~TMessage() = default;
+
+    virtual i16 LowestSupportedVersion() const = 0;
+    virtual i16 HighestSupportedVersion() const = 0;
+    virtual i32 Size(TKafkaVersion version) const = 0;
+    virtual void Read(TKafkaReadable& readable, TKafkaVersion version) = 0;
+    virtual void Write(TKafkaWritable& writable, TKafkaVersion version) const = 0;
+
+    bool operator==(const TMessage& other) const = default;
+};
+
+class TApiMessage : public TMessage {
+public:
+    ~TApiMessage() = default;
+
+    virtual i16 ApiKey() const = 0;
+};
+
+
+std::unique_ptr<TApiMessage> CreateRequest(i16 apiKey);
+std::unique_ptr<TApiMessage> CreateResponse(i16 apiKey);
+
+i16 RequestHeaderVersion(i16 apiKey, TKafkaVersion version);
+i16 ResponseHeaderVersion(i16 apiKey, TKafkaVersion version);
+
+} // namespace NKafka
diff --git a/ydb/core/kafkaproxy/kafka_messages.cpp b/ydb/core/kafkaproxy/kafka_messages.cpp
new file mode 100644
index 00000000000..711a9723a3a
--- /dev/null
+++ b/ydb/core/kafkaproxy/kafka_messages.cpp
@@ -0,0 +1,2331 @@
+
+// THIS CODE IS AUTOMATICALLY GENERATED.  DO NOT EDIT.
+// For generate it use kikimr/tools/kafka/generate.sh
+
+#include "kafka_messages.h"
+
+namespace NKafka {
+
+std::unique_ptr<TApiMessage> CreateRequest(i16 apiKey) {
+    switch (apiKey) {
+        case PRODUCE:
+            return std::make_unique<TProduceRequestData>();
+        case FETCH:
+            return std::make_unique<TFetchRequestData>();
+        case METADATA:
+            return std::make_unique<TMetadataRequestData>();
+        case API_VERSIONS:
+            return std::make_unique<TApiVersionsRequestData>();
+        case INIT_PRODUCER_ID:
+            return std::make_unique<TInitProducerIdRequestData>();
+        default:
+            ythrow yexception() << "Unsupported request API key " <<  apiKey;
+    }
+}
+
+std::unique_ptr<TApiMessage> CreateResponse(i16 apiKey) {
+    switch (apiKey) {
+        case PRODUCE:
+            return std::make_unique<TProduceResponseData>();
+        case FETCH:
+            return std::make_unique<TFetchResponseData>();
+        case METADATA:
+            return std::make_unique<TMetadataResponseData>();
+        case API_VERSIONS:
+            return std::make_unique<TApiVersionsResponseData>();
+        case INIT_PRODUCER_ID:
+            return std::make_unique<TInitProducerIdResponseData>();
+        default:
+            ythrow yexception() << "Unsupported response API key " <<  apiKey;
+    }
+}
+
+TKafkaVersion RequestHeaderVersion(i16 apiKey, TKafkaVersion _version) {
+    switch (apiKey) {
+        case PRODUCE:
+            if (_version >= 9) {
+                return 2;
+            } else {
+                return 1;
+            }
+        case FETCH:
+            if (_version >= 12) {
+                return 2;
+            } else {
+                return 1;
+            }
+        case METADATA:
+            if (_version >= 9) {
+                return 2;
+            } else {
+                return 1;
+            }
+        case API_VERSIONS:
+            if (_version >= 3) {
+                return 2;
+            } else {
+                return 1;
+            }
+        case INIT_PRODUCER_ID:
+            if (_version >= 2) {
+                return 2;
+            } else {
+                return 1;
+            }
+        default:
+            ythrow yexception() << "Unsupported API key " << apiKey;
+            break;
+    }
+}
+
+TKafkaVersion ResponseHeaderVersion(i16 apiKey, TKafkaVersion _version) {
+    switch (apiKey) {
+        case PRODUCE:
+            if (_version >= 9) {
+                return 1;
+            } else {
+                return 0;
+            }
+        case FETCH:
+            if (_version >= 12) {
+                return 1;
+            } else {
+                return 0;
+            }
+        case METADATA:
+            if (_version >= 9) {
+                return 1;
+            } else {
+                return 0;
+            }
+        case API_VERSIONS:
+            // ApiVersionsResponse always includes a v0 header.
+            // See KIP-511 for details.
+            return 0;
+        case INIT_PRODUCER_ID:
+            if (_version >= 2) {
+                return 1;
+            } else {
+                return 0;
+            }
+        default:
+            ythrow yexception() << "Unsupported API key " << apiKey;
+            break;
+    }
+}
+
+
+
+
+
+//
+// TRequestHeaderData
+//
+const TRequestHeaderData::RequestApiKeyMeta::Type TRequestHeaderData::RequestApiKeyMeta::Default = 0;
+const TRequestHeaderData::RequestApiVersionMeta::Type TRequestHeaderData::RequestApiVersionMeta::Default = 0;
+const TRequestHeaderData::CorrelationIdMeta::Type TRequestHeaderData::CorrelationIdMeta::Default = 0;
+const TRequestHeaderData::ClientIdMeta::Type TRequestHeaderData::ClientIdMeta::Default = {""};
+
+TRequestHeaderData::TRequestHeaderData() 
+        : requestApiKey(RequestApiKeyMeta::Default)
+        , requestApiVersion(RequestApiVersionMeta::Default)
+        , correlationId(CorrelationIdMeta::Default)
+        , clientId(ClientIdMeta::Default)
+{}
+
+void TRequestHeaderData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TRequestHeaderData";
+    }
+    NPrivate::Read<RequestApiKeyMeta>(_readable, _version, requestApiKey);
+    NPrivate::Read<RequestApiVersionMeta>(_readable, _version, requestApiVersion);
+    NPrivate::Read<CorrelationIdMeta>(_readable, _version, correlationId);
+    NPrivate::Read<ClientIdMeta>(_readable, _version, clientId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TRequestHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TRequestHeaderData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<RequestApiKeyMeta>(_collector, _writable, _version, requestApiKey);
+    NPrivate::Write<RequestApiVersionMeta>(_collector, _writable, _version, requestApiVersion);
+    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, correlationId);
+    NPrivate::Write<ClientIdMeta>(_collector, _writable, _version, clientId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TRequestHeaderData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<RequestApiKeyMeta>(_collector, _version, requestApiKey);
+    NPrivate::Size<RequestApiVersionMeta>(_collector, _version, requestApiVersion);
+    NPrivate::Size<CorrelationIdMeta>(_collector, _version, correlationId);
+    NPrivate::Size<ClientIdMeta>(_collector, _version, clientId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TResponseHeaderData
+//
+const TResponseHeaderData::CorrelationIdMeta::Type TResponseHeaderData::CorrelationIdMeta::Default = 0;
+
+TResponseHeaderData::TResponseHeaderData() 
+        : correlationId(CorrelationIdMeta::Default)
+{}
+
+void TResponseHeaderData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TResponseHeaderData";
+    }
+    NPrivate::Read<CorrelationIdMeta>(_readable, _version, correlationId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TResponseHeaderData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TResponseHeaderData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<CorrelationIdMeta>(_collector, _writable, _version, correlationId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TResponseHeaderData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<CorrelationIdMeta>(_collector, _version, correlationId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceRequestData
+//
+const TProduceRequestData::TransactionalIdMeta::Type TProduceRequestData::TransactionalIdMeta::Default = std::nullopt;
+const TProduceRequestData::AcksMeta::Type TProduceRequestData::AcksMeta::Default = 0;
+const TProduceRequestData::TimeoutMsMeta::Type TProduceRequestData::TimeoutMsMeta::Default = 0;
+
+TProduceRequestData::TProduceRequestData() 
+        : transactionalId(TransactionalIdMeta::Default)
+        , acks(AcksMeta::Default)
+        , timeoutMs(TimeoutMsMeta::Default)
+{}
+
+void TProduceRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData";
+    }
+    NPrivate::Read<TransactionalIdMeta>(_readable, _version, transactionalId);
+    NPrivate::Read<AcksMeta>(_readable, _version, acks);
+    NPrivate::Read<TimeoutMsMeta>(_readable, _version, timeoutMs);
+    NPrivate::Read<TopicDataMeta>(_readable, _version, topicData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, transactionalId);
+    NPrivate::Write<AcksMeta>(_collector, _writable, _version, acks);
+    NPrivate::Write<TimeoutMsMeta>(_collector, _writable, _version, timeoutMs);
+    NPrivate::Write<TopicDataMeta>(_collector, _writable, _version, topicData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceRequestData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TransactionalIdMeta>(_collector, _version, transactionalId);
+    NPrivate::Size<AcksMeta>(_collector, _version, acks);
+    NPrivate::Size<TimeoutMsMeta>(_collector, _version, timeoutMs);
+    NPrivate::Size<TopicDataMeta>(_collector, _version, topicData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceRequestData::TTopicProduceData
+//
+const TProduceRequestData::TTopicProduceData::NameMeta::Type TProduceRequestData::TTopicProduceData::NameMeta::Default = {""};
+
+TProduceRequestData::TTopicProduceData::TTopicProduceData() 
+        : name(NameMeta::Default)
+{}
+
+void TProduceRequestData::TTopicProduceData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData::TTopicProduceData";
+    }
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    NPrivate::Read<PartitionDataMeta>(_readable, _version, partitionData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceRequestData::TTopicProduceData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData::TTopicProduceData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<PartitionDataMeta>(_collector, _writable, _version, partitionData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceRequestData::TTopicProduceData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<PartitionDataMeta>(_collector, _version, partitionData);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceRequestData::TTopicProduceData::TPartitionProduceData
+//
+const TProduceRequestData::TTopicProduceData::TPartitionProduceData::IndexMeta::Type TProduceRequestData::TTopicProduceData::TPartitionProduceData::IndexMeta::Default = 0;
+
+TProduceRequestData::TTopicProduceData::TPartitionProduceData::TPartitionProduceData() 
+        : index(IndexMeta::Default)
+{}
+
+void TProduceRequestData::TTopicProduceData::TPartitionProduceData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceRequestData::TTopicProduceData::TPartitionProduceData";
+    }
+    NPrivate::Read<IndexMeta>(_readable, _version, index);
+    NPrivate::Read<RecordsMeta>(_readable, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceRequestData::TTopicProduceData::TPartitionProduceData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceRequestData::TTopicProduceData::TPartitionProduceData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<IndexMeta>(_collector, _writable, _version, index);
+    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceRequestData::TTopicProduceData::TPartitionProduceData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<IndexMeta>(_collector, _version, index);
+    NPrivate::Size<RecordsMeta>(_collector, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceResponseData
+//
+const TProduceResponseData::ThrottleTimeMsMeta::Type TProduceResponseData::ThrottleTimeMsMeta::Default = 0;
+
+TProduceResponseData::TProduceResponseData() 
+        : throttleTimeMs(ThrottleTimeMsMeta::Default)
+{}
+
+void TProduceResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData";
+    }
+    NPrivate::Read<ResponsesMeta>(_readable, _version, responses);
+    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, responses);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceResponseData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ResponsesMeta>(_collector, _version, responses);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceResponseData::TTopicProduceResponse
+//
+const TProduceResponseData::TTopicProduceResponse::NameMeta::Type TProduceResponseData::TTopicProduceResponse::NameMeta::Default = {""};
+
+TProduceResponseData::TTopicProduceResponse::TTopicProduceResponse() 
+        : name(NameMeta::Default)
+{}
+
+void TProduceResponseData::TTopicProduceResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse";
+    }
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    NPrivate::Read<PartitionResponsesMeta>(_readable, _version, partitionResponses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceResponseData::TTopicProduceResponse::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<PartitionResponsesMeta>(_collector, _writable, _version, partitionResponses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceResponseData::TTopicProduceResponse::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<PartitionResponsesMeta>(_collector, _version, partitionResponses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse
+//
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::IndexMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::IndexMeta::Default = 0;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorCodeMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorCodeMeta::Default = 0;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::BaseOffsetMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::BaseOffsetMeta::Default = 0;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::LogAppendTimeMsMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::LogAppendTimeMsMeta::Default = -1;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::LogStartOffsetMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::LogStartOffsetMeta::Default = -1;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorMessageMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::ErrorMessageMeta::Default = std::nullopt;
+
+TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TPartitionProduceResponse() 
+        : index(IndexMeta::Default)
+        , errorCode(ErrorCodeMeta::Default)
+        , baseOffset(BaseOffsetMeta::Default)
+        , logAppendTimeMs(LogAppendTimeMsMeta::Default)
+        , logStartOffset(LogStartOffsetMeta::Default)
+        , errorMessage(ErrorMessageMeta::Default)
+{}
+
+void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse";
+    }
+    NPrivate::Read<IndexMeta>(_readable, _version, index);
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<BaseOffsetMeta>(_readable, _version, baseOffset);
+    NPrivate::Read<LogAppendTimeMsMeta>(_readable, _version, logAppendTimeMs);
+    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
+    NPrivate::Read<RecordErrorsMeta>(_readable, _version, recordErrors);
+    NPrivate::Read<ErrorMessageMeta>(_readable, _version, errorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<IndexMeta>(_collector, _writable, _version, index);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<BaseOffsetMeta>(_collector, _writable, _version, baseOffset);
+    NPrivate::Write<LogAppendTimeMsMeta>(_collector, _writable, _version, logAppendTimeMs);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
+    NPrivate::Write<RecordErrorsMeta>(_collector, _writable, _version, recordErrors);
+    NPrivate::Write<ErrorMessageMeta>(_collector, _writable, _version, errorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<IndexMeta>(_collector, _version, index);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<BaseOffsetMeta>(_collector, _version, baseOffset);
+    NPrivate::Size<LogAppendTimeMsMeta>(_collector, _version, logAppendTimeMs);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
+    NPrivate::Size<RecordErrorsMeta>(_collector, _version, recordErrors);
+    NPrivate::Size<ErrorMessageMeta>(_collector, _version, errorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage
+//
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexMeta::Default = 0;
+const TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexErrorMessageMeta::Type TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::BatchIndexErrorMessageMeta::Default = std::nullopt;
+
+TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::TBatchIndexAndErrorMessage() 
+        : batchIndex(BatchIndexMeta::Default)
+        , batchIndexErrorMessage(BatchIndexErrorMessageMeta::Default)
+{}
+
+void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage";
+    }
+    NPrivate::Read<BatchIndexMeta>(_readable, _version, batchIndex);
+    NPrivate::Read<BatchIndexErrorMessageMeta>(_readable, _version, batchIndexErrorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<BatchIndexMeta>(_collector, _writable, _version, batchIndex);
+    NPrivate::Write<BatchIndexErrorMessageMeta>(_collector, _writable, _version, batchIndexErrorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TProduceResponseData::TTopicProduceResponse::TPartitionProduceResponse::TBatchIndexAndErrorMessage::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<BatchIndexMeta>(_collector, _version, batchIndex);
+    NPrivate::Size<BatchIndexErrorMessageMeta>(_collector, _version, batchIndexErrorMessage);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchRequestData
+//
+const TFetchRequestData::ClusterIdMeta::Type TFetchRequestData::ClusterIdMeta::Default = std::nullopt;
+const TFetchRequestData::ReplicaIdMeta::Type TFetchRequestData::ReplicaIdMeta::Default = 0;
+const TFetchRequestData::MaxWaitMsMeta::Type TFetchRequestData::MaxWaitMsMeta::Default = 0;
+const TFetchRequestData::MinBytesMeta::Type TFetchRequestData::MinBytesMeta::Default = 0;
+const TFetchRequestData::MaxBytesMeta::Type TFetchRequestData::MaxBytesMeta::Default = 0x7fffffff;
+const TFetchRequestData::IsolationLevelMeta::Type TFetchRequestData::IsolationLevelMeta::Default = 0;
+const TFetchRequestData::SessionIdMeta::Type TFetchRequestData::SessionIdMeta::Default = 0;
+const TFetchRequestData::SessionEpochMeta::Type TFetchRequestData::SessionEpochMeta::Default = -1;
+const TFetchRequestData::RackIdMeta::Type TFetchRequestData::RackIdMeta::Default = {""};
+
+TFetchRequestData::TFetchRequestData() 
+        : clusterId(ClusterIdMeta::Default)
+        , replicaId(ReplicaIdMeta::Default)
+        , maxWaitMs(MaxWaitMsMeta::Default)
+        , minBytes(MinBytesMeta::Default)
+        , maxBytes(MaxBytesMeta::Default)
+        , isolationLevel(IsolationLevelMeta::Default)
+        , sessionId(SessionIdMeta::Default)
+        , sessionEpoch(SessionEpochMeta::Default)
+        , rackId(RackIdMeta::Default)
+{}
+
+void TFetchRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData";
+    }
+    NPrivate::Read<ClusterIdMeta>(_readable, _version, clusterId);
+    NPrivate::Read<ReplicaIdMeta>(_readable, _version, replicaId);
+    NPrivate::Read<MaxWaitMsMeta>(_readable, _version, maxWaitMs);
+    NPrivate::Read<MinBytesMeta>(_readable, _version, minBytes);
+    NPrivate::Read<MaxBytesMeta>(_readable, _version, maxBytes);
+    NPrivate::Read<IsolationLevelMeta>(_readable, _version, isolationLevel);
+    NPrivate::Read<SessionIdMeta>(_readable, _version, sessionId);
+    NPrivate::Read<SessionEpochMeta>(_readable, _version, sessionEpoch);
+    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
+    NPrivate::Read<ForgottenTopicsDataMeta>(_readable, _version, forgottenTopicsData);
+    NPrivate::Read<RackIdMeta>(_readable, _version, rackId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                case ClusterIdMeta::Tag:
+                    NPrivate::ReadTag<ClusterIdMeta>(_readable, _version, clusterId);
+                    break;
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, clusterId);
+    NPrivate::Write<ReplicaIdMeta>(_collector, _writable, _version, replicaId);
+    NPrivate::Write<MaxWaitMsMeta>(_collector, _writable, _version, maxWaitMs);
+    NPrivate::Write<MinBytesMeta>(_collector, _writable, _version, minBytes);
+    NPrivate::Write<MaxBytesMeta>(_collector, _writable, _version, maxBytes);
+    NPrivate::Write<IsolationLevelMeta>(_collector, _writable, _version, isolationLevel);
+    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, sessionId);
+    NPrivate::Write<SessionEpochMeta>(_collector, _writable, _version, sessionEpoch);
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
+    NPrivate::Write<ForgottenTopicsDataMeta>(_collector, _writable, _version, forgottenTopicsData);
+    NPrivate::Write<RackIdMeta>(_collector, _writable, _version, rackId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+        NPrivate::WriteTag<ClusterIdMeta>(_writable, _version, clusterId);
+    }
+}
+
+i32 TFetchRequestData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ClusterIdMeta>(_collector, _version, clusterId);
+    NPrivate::Size<ReplicaIdMeta>(_collector, _version, replicaId);
+    NPrivate::Size<MaxWaitMsMeta>(_collector, _version, maxWaitMs);
+    NPrivate::Size<MinBytesMeta>(_collector, _version, minBytes);
+    NPrivate::Size<MaxBytesMeta>(_collector, _version, maxBytes);
+    NPrivate::Size<IsolationLevelMeta>(_collector, _version, isolationLevel);
+    NPrivate::Size<SessionIdMeta>(_collector, _version, sessionId);
+    NPrivate::Size<SessionEpochMeta>(_collector, _version, sessionEpoch);
+    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
+    NPrivate::Size<ForgottenTopicsDataMeta>(_collector, _version, forgottenTopicsData);
+    NPrivate::Size<RackIdMeta>(_collector, _version, rackId);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchRequestData::TFetchTopic
+//
+const TFetchRequestData::TFetchTopic::TopicMeta::Type TFetchRequestData::TFetchTopic::TopicMeta::Default = {""};
+const TFetchRequestData::TFetchTopic::TopicIdMeta::Type TFetchRequestData::TFetchTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
+
+TFetchRequestData::TFetchTopic::TFetchTopic() 
+        : topic(TopicMeta::Default)
+        , topicId(TopicIdMeta::Default)
+{}
+
+void TFetchRequestData::TFetchTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TFetchTopic";
+    }
+    NPrivate::Read<TopicMeta>(_readable, _version, topic);
+    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
+    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchRequestData::TFetchTopic::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TFetchTopic";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchRequestData::TFetchTopic::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TopicMeta>(_collector, _version, topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchRequestData::TFetchTopic::TFetchPartition
+//
+const TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMeta::Default = 0;
+const TFetchRequestData::TFetchTopic::TFetchPartition::CurrentLeaderEpochMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::CurrentLeaderEpochMeta::Default = -1;
+const TFetchRequestData::TFetchTopic::TFetchPartition::FetchOffsetMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::FetchOffsetMeta::Default = 0;
+const TFetchRequestData::TFetchTopic::TFetchPartition::LastFetchedEpochMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::LastFetchedEpochMeta::Default = -1;
+const TFetchRequestData::TFetchTopic::TFetchPartition::LogStartOffsetMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::LogStartOffsetMeta::Default = -1;
+const TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMaxBytesMeta::Type TFetchRequestData::TFetchTopic::TFetchPartition::PartitionMaxBytesMeta::Default = 0;
+
+TFetchRequestData::TFetchTopic::TFetchPartition::TFetchPartition() 
+        : partition(PartitionMeta::Default)
+        , currentLeaderEpoch(CurrentLeaderEpochMeta::Default)
+        , fetchOffset(FetchOffsetMeta::Default)
+        , lastFetchedEpoch(LastFetchedEpochMeta::Default)
+        , logStartOffset(LogStartOffsetMeta::Default)
+        , partitionMaxBytes(PartitionMaxBytesMeta::Default)
+{}
+
+void TFetchRequestData::TFetchTopic::TFetchPartition::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TFetchTopic::TFetchPartition";
+    }
+    NPrivate::Read<PartitionMeta>(_readable, _version, partition);
+    NPrivate::Read<CurrentLeaderEpochMeta>(_readable, _version, currentLeaderEpoch);
+    NPrivate::Read<FetchOffsetMeta>(_readable, _version, fetchOffset);
+    NPrivate::Read<LastFetchedEpochMeta>(_readable, _version, lastFetchedEpoch);
+    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
+    NPrivate::Read<PartitionMaxBytesMeta>(_readable, _version, partitionMaxBytes);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchRequestData::TFetchTopic::TFetchPartition::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TFetchTopic::TFetchPartition";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<PartitionMeta>(_collector, _writable, _version, partition);
+    NPrivate::Write<CurrentLeaderEpochMeta>(_collector, _writable, _version, currentLeaderEpoch);
+    NPrivate::Write<FetchOffsetMeta>(_collector, _writable, _version, fetchOffset);
+    NPrivate::Write<LastFetchedEpochMeta>(_collector, _writable, _version, lastFetchedEpoch);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
+    NPrivate::Write<PartitionMaxBytesMeta>(_collector, _writable, _version, partitionMaxBytes);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchRequestData::TFetchTopic::TFetchPartition::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<PartitionMeta>(_collector, _version, partition);
+    NPrivate::Size<CurrentLeaderEpochMeta>(_collector, _version, currentLeaderEpoch);
+    NPrivate::Size<FetchOffsetMeta>(_collector, _version, fetchOffset);
+    NPrivate::Size<LastFetchedEpochMeta>(_collector, _version, lastFetchedEpoch);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
+    NPrivate::Size<PartitionMaxBytesMeta>(_collector, _version, partitionMaxBytes);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchRequestData::TForgottenTopic
+//
+const TFetchRequestData::TForgottenTopic::TopicMeta::Type TFetchRequestData::TForgottenTopic::TopicMeta::Default = {""};
+const TFetchRequestData::TForgottenTopic::TopicIdMeta::Type TFetchRequestData::TForgottenTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
+
+TFetchRequestData::TForgottenTopic::TForgottenTopic() 
+        : topic(TopicMeta::Default)
+        , topicId(TopicIdMeta::Default)
+{}
+
+void TFetchRequestData::TForgottenTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchRequestData::TForgottenTopic";
+    }
+    NPrivate::Read<TopicMeta>(_readable, _version, topic);
+    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
+    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchRequestData::TForgottenTopic::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchRequestData::TForgottenTopic";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchRequestData::TForgottenTopic::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TopicMeta>(_collector, _version, topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData
+//
+const TFetchResponseData::ThrottleTimeMsMeta::Type TFetchResponseData::ThrottleTimeMsMeta::Default = 0;
+const TFetchResponseData::ErrorCodeMeta::Type TFetchResponseData::ErrorCodeMeta::Default = 0;
+const TFetchResponseData::SessionIdMeta::Type TFetchResponseData::SessionIdMeta::Default = 0;
+
+TFetchResponseData::TFetchResponseData() 
+        : throttleTimeMs(ThrottleTimeMsMeta::Default)
+        , errorCode(ErrorCodeMeta::Default)
+        , sessionId(SessionIdMeta::Default)
+{}
+
+void TFetchResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData";
+    }
+    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<SessionIdMeta>(_readable, _version, sessionId);
+    NPrivate::Read<ResponsesMeta>(_readable, _version, responses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<SessionIdMeta>(_collector, _writable, _version, sessionId);
+    NPrivate::Write<ResponsesMeta>(_collector, _writable, _version, responses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<SessionIdMeta>(_collector, _version, sessionId);
+    NPrivate::Size<ResponsesMeta>(_collector, _version, responses);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse
+//
+const TFetchResponseData::TFetchableTopicResponse::TopicMeta::Type TFetchResponseData::TFetchableTopicResponse::TopicMeta::Default = {""};
+const TFetchResponseData::TFetchableTopicResponse::TopicIdMeta::Type TFetchResponseData::TFetchableTopicResponse::TopicIdMeta::Default = TKafkaUuid(0, 0);
+
+TFetchResponseData::TFetchableTopicResponse::TFetchableTopicResponse() 
+        : topic(TopicMeta::Default)
+        , topicId(TopicIdMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse";
+    }
+    NPrivate::Read<TopicMeta>(_readable, _version, topic);
+    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
+    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TopicMeta>(_collector, _writable, _version, topic);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TopicMeta>(_collector, _version, topic);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse::TPartitionData
+//
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::PartitionIndexMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::PartitionIndexMeta::Default = 0;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::ErrorCodeMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::ErrorCodeMeta::Default = 0;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::HighWatermarkMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::HighWatermarkMeta::Default = 0;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::LastStableOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::LastStableOffsetMeta::Default = -1;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::LogStartOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::LogStartOffsetMeta::Default = -1;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::PreferredReadReplicaMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::PreferredReadReplicaMeta::Default = -1;
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TPartitionData() 
+        : partitionIndex(PartitionIndexMeta::Default)
+        , errorCode(ErrorCodeMeta::Default)
+        , highWatermark(HighWatermarkMeta::Default)
+        , lastStableOffset(LastStableOffsetMeta::Default)
+        , logStartOffset(LogStartOffsetMeta::Default)
+        , preferredReadReplica(PreferredReadReplicaMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData";
+    }
+    NPrivate::Read<PartitionIndexMeta>(_readable, _version, partitionIndex);
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<HighWatermarkMeta>(_readable, _version, highWatermark);
+    NPrivate::Read<LastStableOffsetMeta>(_readable, _version, lastStableOffset);
+    NPrivate::Read<LogStartOffsetMeta>(_readable, _version, logStartOffset);
+    NPrivate::Read<DivergingEpochMeta>(_readable, _version, divergingEpoch);
+    NPrivate::Read<CurrentLeaderMeta>(_readable, _version, currentLeader);
+    NPrivate::Read<SnapshotIdMeta>(_readable, _version, snapshotId);
+    NPrivate::Read<AbortedTransactionsMeta>(_readable, _version, abortedTransactions);
+    NPrivate::Read<PreferredReadReplicaMeta>(_readable, _version, preferredReadReplica);
+    NPrivate::Read<RecordsMeta>(_readable, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                case DivergingEpochMeta::Tag:
+                    NPrivate::ReadTag<DivergingEpochMeta>(_readable, _version, divergingEpoch);
+                    break;
+                case CurrentLeaderMeta::Tag:
+                    NPrivate::ReadTag<CurrentLeaderMeta>(_readable, _version, currentLeader);
+                    break;
+                case SnapshotIdMeta::Tag:
+                    NPrivate::ReadTag<SnapshotIdMeta>(_readable, _version, snapshotId);
+                    break;
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, partitionIndex);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<HighWatermarkMeta>(_collector, _writable, _version, highWatermark);
+    NPrivate::Write<LastStableOffsetMeta>(_collector, _writable, _version, lastStableOffset);
+    NPrivate::Write<LogStartOffsetMeta>(_collector, _writable, _version, logStartOffset);
+    NPrivate::Write<DivergingEpochMeta>(_collector, _writable, _version, divergingEpoch);
+    NPrivate::Write<CurrentLeaderMeta>(_collector, _writable, _version, currentLeader);
+    NPrivate::Write<SnapshotIdMeta>(_collector, _writable, _version, snapshotId);
+    NPrivate::Write<AbortedTransactionsMeta>(_collector, _writable, _version, abortedTransactions);
+    NPrivate::Write<PreferredReadReplicaMeta>(_collector, _writable, _version, preferredReadReplica);
+    NPrivate::Write<RecordsMeta>(_collector, _writable, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+        NPrivate::WriteTag<DivergingEpochMeta>(_writable, _version, divergingEpoch);
+        NPrivate::WriteTag<CurrentLeaderMeta>(_writable, _version, currentLeader);
+        NPrivate::WriteTag<SnapshotIdMeta>(_writable, _version, snapshotId);
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<PartitionIndexMeta>(_collector, _version, partitionIndex);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<HighWatermarkMeta>(_collector, _version, highWatermark);
+    NPrivate::Size<LastStableOffsetMeta>(_collector, _version, lastStableOffset);
+    NPrivate::Size<LogStartOffsetMeta>(_collector, _version, logStartOffset);
+    NPrivate::Size<DivergingEpochMeta>(_collector, _version, divergingEpoch);
+    NPrivate::Size<CurrentLeaderMeta>(_collector, _version, currentLeader);
+    NPrivate::Size<SnapshotIdMeta>(_collector, _version, snapshotId);
+    NPrivate::Size<AbortedTransactionsMeta>(_collector, _version, abortedTransactions);
+    NPrivate::Size<PreferredReadReplicaMeta>(_collector, _version, preferredReadReplica);
+    NPrivate::Size<RecordsMeta>(_collector, _version, records);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset
+//
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EpochMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EpochMeta::Default = -1;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EndOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::EndOffsetMeta::Default = -1;
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::TEpochEndOffset() 
+        : epoch(EpochMeta::Default)
+        , endOffset(EndOffsetMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset";
+    }
+    NPrivate::Read<EpochMeta>(_readable, _version, epoch);
+    NPrivate::Read<EndOffsetMeta>(_readable, _version, endOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<EpochMeta>(_collector, _writable, _version, epoch);
+    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, endOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TEpochEndOffset::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<EpochMeta>(_collector, _version, epoch);
+    NPrivate::Size<EndOffsetMeta>(_collector, _version, endOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch
+//
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderIdMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderIdMeta::Default = -1;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderEpochMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::LeaderEpochMeta::Default = -1;
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::TLeaderIdAndEpoch() 
+        : leaderId(LeaderIdMeta::Default)
+        , leaderEpoch(LeaderEpochMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch";
+    }
+    NPrivate::Read<LeaderIdMeta>(_readable, _version, leaderId);
+    NPrivate::Read<LeaderEpochMeta>(_readable, _version, leaderEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, leaderId);
+    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, leaderEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TLeaderIdAndEpoch::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<LeaderIdMeta>(_collector, _version, leaderId);
+    NPrivate::Size<LeaderEpochMeta>(_collector, _version, leaderEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId
+//
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EndOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EndOffsetMeta::Default = -1;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EpochMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::EpochMeta::Default = -1;
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::TSnapshotId() 
+        : endOffset(EndOffsetMeta::Default)
+        , epoch(EpochMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId";
+    }
+    NPrivate::Read<EndOffsetMeta>(_readable, _version, endOffset);
+    NPrivate::Read<EpochMeta>(_readable, _version, epoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<EndOffsetMeta>(_collector, _writable, _version, endOffset);
+    NPrivate::Write<EpochMeta>(_collector, _writable, _version, epoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TSnapshotId::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<EndOffsetMeta>(_collector, _version, endOffset);
+    NPrivate::Size<EpochMeta>(_collector, _version, epoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction
+//
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::ProducerIdMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::ProducerIdMeta::Default = 0;
+const TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::FirstOffsetMeta::Type TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::FirstOffsetMeta::Default = 0;
+
+TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::TAbortedTransaction() 
+        : producerId(ProducerIdMeta::Default)
+        , firstOffset(FirstOffsetMeta::Default)
+{}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction";
+    }
+    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
+    NPrivate::Read<FirstOffsetMeta>(_readable, _version, firstOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
+    NPrivate::Write<FirstOffsetMeta>(_collector, _writable, _version, firstOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TFetchResponseData::TFetchableTopicResponse::TPartitionData::TAbortedTransaction::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
+    NPrivate::Size<FirstOffsetMeta>(_collector, _version, firstOffset);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataRequestData
+//
+const TMetadataRequestData::AllowAutoTopicCreationMeta::Type TMetadataRequestData::AllowAutoTopicCreationMeta::Default = true;
+const TMetadataRequestData::IncludeClusterAuthorizedOperationsMeta::Type TMetadataRequestData::IncludeClusterAuthorizedOperationsMeta::Default = false;
+const TMetadataRequestData::IncludeTopicAuthorizedOperationsMeta::Type TMetadataRequestData::IncludeTopicAuthorizedOperationsMeta::Default = false;
+
+TMetadataRequestData::TMetadataRequestData() 
+        : allowAutoTopicCreation(AllowAutoTopicCreationMeta::Default)
+        , includeClusterAuthorizedOperations(IncludeClusterAuthorizedOperationsMeta::Default)
+        , includeTopicAuthorizedOperations(IncludeTopicAuthorizedOperationsMeta::Default)
+{}
+
+void TMetadataRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataRequestData";
+    }
+    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
+    NPrivate::Read<AllowAutoTopicCreationMeta>(_readable, _version, allowAutoTopicCreation);
+    NPrivate::Read<IncludeClusterAuthorizedOperationsMeta>(_readable, _version, includeClusterAuthorizedOperations);
+    NPrivate::Read<IncludeTopicAuthorizedOperationsMeta>(_readable, _version, includeTopicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataRequestData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
+    NPrivate::Write<AllowAutoTopicCreationMeta>(_collector, _writable, _version, allowAutoTopicCreation);
+    NPrivate::Write<IncludeClusterAuthorizedOperationsMeta>(_collector, _writable, _version, includeClusterAuthorizedOperations);
+    NPrivate::Write<IncludeTopicAuthorizedOperationsMeta>(_collector, _writable, _version, includeTopicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataRequestData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
+    NPrivate::Size<AllowAutoTopicCreationMeta>(_collector, _version, allowAutoTopicCreation);
+    NPrivate::Size<IncludeClusterAuthorizedOperationsMeta>(_collector, _version, includeClusterAuthorizedOperations);
+    NPrivate::Size<IncludeTopicAuthorizedOperationsMeta>(_collector, _version, includeTopicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataRequestData::TMetadataRequestTopic
+//
+const TMetadataRequestData::TMetadataRequestTopic::TopicIdMeta::Type TMetadataRequestData::TMetadataRequestTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
+const TMetadataRequestData::TMetadataRequestTopic::NameMeta::Type TMetadataRequestData::TMetadataRequestTopic::NameMeta::Default = {""};
+
+TMetadataRequestData::TMetadataRequestTopic::TMetadataRequestTopic() 
+        : topicId(TopicIdMeta::Default)
+        , name(NameMeta::Default)
+{}
+
+void TMetadataRequestData::TMetadataRequestTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataRequestData::TMetadataRequestTopic";
+    }
+    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataRequestData::TMetadataRequestTopic::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataRequestData::TMetadataRequestTopic";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataRequestData::TMetadataRequestTopic::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataResponseData
+//
+const TMetadataResponseData::ThrottleTimeMsMeta::Type TMetadataResponseData::ThrottleTimeMsMeta::Default = 0;
+const TMetadataResponseData::ClusterIdMeta::Type TMetadataResponseData::ClusterIdMeta::Default = std::nullopt;
+const TMetadataResponseData::ControllerIdMeta::Type TMetadataResponseData::ControllerIdMeta::Default = -1;
+const TMetadataResponseData::ClusterAuthorizedOperationsMeta::Type TMetadataResponseData::ClusterAuthorizedOperationsMeta::Default = -2147483648;
+
+TMetadataResponseData::TMetadataResponseData() 
+        : throttleTimeMs(ThrottleTimeMsMeta::Default)
+        , clusterId(ClusterIdMeta::Default)
+        , controllerId(ControllerIdMeta::Default)
+        , clusterAuthorizedOperations(ClusterAuthorizedOperationsMeta::Default)
+{}
+
+void TMetadataResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData";
+    }
+    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+    NPrivate::Read<BrokersMeta>(_readable, _version, brokers);
+    NPrivate::Read<ClusterIdMeta>(_readable, _version, clusterId);
+    NPrivate::Read<ControllerIdMeta>(_readable, _version, controllerId);
+    NPrivate::Read<TopicsMeta>(_readable, _version, topics);
+    NPrivate::Read<ClusterAuthorizedOperationsMeta>(_readable, _version, clusterAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    NPrivate::Write<BrokersMeta>(_collector, _writable, _version, brokers);
+    NPrivate::Write<ClusterIdMeta>(_collector, _writable, _version, clusterId);
+    NPrivate::Write<ControllerIdMeta>(_collector, _writable, _version, controllerId);
+    NPrivate::Write<TopicsMeta>(_collector, _writable, _version, topics);
+    NPrivate::Write<ClusterAuthorizedOperationsMeta>(_collector, _writable, _version, clusterAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataResponseData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    NPrivate::Size<BrokersMeta>(_collector, _version, brokers);
+    NPrivate::Size<ClusterIdMeta>(_collector, _version, clusterId);
+    NPrivate::Size<ControllerIdMeta>(_collector, _version, controllerId);
+    NPrivate::Size<TopicsMeta>(_collector, _version, topics);
+    NPrivate::Size<ClusterAuthorizedOperationsMeta>(_collector, _version, clusterAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataResponseData::TMetadataResponseBroker
+//
+const TMetadataResponseData::TMetadataResponseBroker::NodeIdMeta::Type TMetadataResponseData::TMetadataResponseBroker::NodeIdMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseBroker::HostMeta::Type TMetadataResponseData::TMetadataResponseBroker::HostMeta::Default = {""};
+const TMetadataResponseData::TMetadataResponseBroker::PortMeta::Type TMetadataResponseData::TMetadataResponseBroker::PortMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseBroker::RackMeta::Type TMetadataResponseData::TMetadataResponseBroker::RackMeta::Default = std::nullopt;
+
+TMetadataResponseData::TMetadataResponseBroker::TMetadataResponseBroker() 
+        : nodeId(NodeIdMeta::Default)
+        , host(HostMeta::Default)
+        , port(PortMeta::Default)
+        , rack(RackMeta::Default)
+{}
+
+void TMetadataResponseData::TMetadataResponseBroker::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseBroker";
+    }
+    NPrivate::Read<NodeIdMeta>(_readable, _version, nodeId);
+    NPrivate::Read<HostMeta>(_readable, _version, host);
+    NPrivate::Read<PortMeta>(_readable, _version, port);
+    NPrivate::Read<RackMeta>(_readable, _version, rack);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataResponseData::TMetadataResponseBroker::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseBroker";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<NodeIdMeta>(_collector, _writable, _version, nodeId);
+    NPrivate::Write<HostMeta>(_collector, _writable, _version, host);
+    NPrivate::Write<PortMeta>(_collector, _writable, _version, port);
+    NPrivate::Write<RackMeta>(_collector, _writable, _version, rack);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataResponseData::TMetadataResponseBroker::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<NodeIdMeta>(_collector, _version, nodeId);
+    NPrivate::Size<HostMeta>(_collector, _version, host);
+    NPrivate::Size<PortMeta>(_collector, _version, port);
+    NPrivate::Size<RackMeta>(_collector, _version, rack);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataResponseData::TMetadataResponseTopic
+//
+const TMetadataResponseData::TMetadataResponseTopic::ErrorCodeMeta::Type TMetadataResponseData::TMetadataResponseTopic::ErrorCodeMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseTopic::NameMeta::Type TMetadataResponseData::TMetadataResponseTopic::NameMeta::Default = {""};
+const TMetadataResponseData::TMetadataResponseTopic::TopicIdMeta::Type TMetadataResponseData::TMetadataResponseTopic::TopicIdMeta::Default = TKafkaUuid(0, 0);
+const TMetadataResponseData::TMetadataResponseTopic::IsInternalMeta::Type TMetadataResponseData::TMetadataResponseTopic::IsInternalMeta::Default = false;
+const TMetadataResponseData::TMetadataResponseTopic::TopicAuthorizedOperationsMeta::Type TMetadataResponseData::TMetadataResponseTopic::TopicAuthorizedOperationsMeta::Default = -2147483648;
+
+TMetadataResponseData::TMetadataResponseTopic::TMetadataResponseTopic() 
+        : errorCode(ErrorCodeMeta::Default)
+        , name(NameMeta::Default)
+        , topicId(TopicIdMeta::Default)
+        , isInternal(IsInternalMeta::Default)
+        , topicAuthorizedOperations(TopicAuthorizedOperationsMeta::Default)
+{}
+
+void TMetadataResponseData::TMetadataResponseTopic::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseTopic";
+    }
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    NPrivate::Read<TopicIdMeta>(_readable, _version, topicId);
+    NPrivate::Read<IsInternalMeta>(_readable, _version, isInternal);
+    NPrivate::Read<PartitionsMeta>(_readable, _version, partitions);
+    NPrivate::Read<TopicAuthorizedOperationsMeta>(_readable, _version, topicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataResponseData::TMetadataResponseTopic::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseTopic";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<TopicIdMeta>(_collector, _writable, _version, topicId);
+    NPrivate::Write<IsInternalMeta>(_collector, _writable, _version, isInternal);
+    NPrivate::Write<PartitionsMeta>(_collector, _writable, _version, partitions);
+    NPrivate::Write<TopicAuthorizedOperationsMeta>(_collector, _writable, _version, topicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataResponseData::TMetadataResponseTopic::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<TopicIdMeta>(_collector, _version, topicId);
+    NPrivate::Size<IsInternalMeta>(_collector, _version, isInternal);
+    NPrivate::Size<PartitionsMeta>(_collector, _version, partitions);
+    NPrivate::Size<TopicAuthorizedOperationsMeta>(_collector, _version, topicAuthorizedOperations);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition
+//
+const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::ErrorCodeMeta::Type TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::ErrorCodeMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::PartitionIndexMeta::Type TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::PartitionIndexMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderIdMeta::Type TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderIdMeta::Default = 0;
+const TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderEpochMeta::Type TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::LeaderEpochMeta::Default = -1;
+
+TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::TMetadataResponsePartition() 
+        : errorCode(ErrorCodeMeta::Default)
+        , partitionIndex(PartitionIndexMeta::Default)
+        , leaderId(LeaderIdMeta::Default)
+        , leaderEpoch(LeaderEpochMeta::Default)
+{}
+
+void TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition";
+    }
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<PartitionIndexMeta>(_readable, _version, partitionIndex);
+    NPrivate::Read<LeaderIdMeta>(_readable, _version, leaderId);
+    NPrivate::Read<LeaderEpochMeta>(_readable, _version, leaderEpoch);
+    NPrivate::Read<ReplicaNodesMeta>(_readable, _version, replicaNodes);
+    NPrivate::Read<IsrNodesMeta>(_readable, _version, isrNodes);
+    NPrivate::Read<OfflineReplicasMeta>(_readable, _version, offlineReplicas);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<PartitionIndexMeta>(_collector, _writable, _version, partitionIndex);
+    NPrivate::Write<LeaderIdMeta>(_collector, _writable, _version, leaderId);
+    NPrivate::Write<LeaderEpochMeta>(_collector, _writable, _version, leaderEpoch);
+    NPrivate::Write<ReplicaNodesMeta>(_collector, _writable, _version, replicaNodes);
+    NPrivate::Write<IsrNodesMeta>(_collector, _writable, _version, isrNodes);
+    NPrivate::Write<OfflineReplicasMeta>(_collector, _writable, _version, offlineReplicas);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TMetadataResponseData::TMetadataResponseTopic::TMetadataResponsePartition::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<PartitionIndexMeta>(_collector, _version, partitionIndex);
+    NPrivate::Size<LeaderIdMeta>(_collector, _version, leaderId);
+    NPrivate::Size<LeaderEpochMeta>(_collector, _version, leaderEpoch);
+    NPrivate::Size<ReplicaNodesMeta>(_collector, _version, replicaNodes);
+    NPrivate::Size<IsrNodesMeta>(_collector, _version, isrNodes);
+    NPrivate::Size<OfflineReplicasMeta>(_collector, _version, offlineReplicas);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TApiVersionsRequestData
+//
+const TApiVersionsRequestData::ClientSoftwareNameMeta::Type TApiVersionsRequestData::ClientSoftwareNameMeta::Default = {""};
+const TApiVersionsRequestData::ClientSoftwareVersionMeta::Type TApiVersionsRequestData::ClientSoftwareVersionMeta::Default = {""};
+
+TApiVersionsRequestData::TApiVersionsRequestData() 
+        : clientSoftwareName(ClientSoftwareNameMeta::Default)
+        , clientSoftwareVersion(ClientSoftwareVersionMeta::Default)
+{}
+
+void TApiVersionsRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsRequestData";
+    }
+    NPrivate::Read<ClientSoftwareNameMeta>(_readable, _version, clientSoftwareName);
+    NPrivate::Read<ClientSoftwareVersionMeta>(_readable, _version, clientSoftwareVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TApiVersionsRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TApiVersionsRequestData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ClientSoftwareNameMeta>(_collector, _writable, _version, clientSoftwareName);
+    NPrivate::Write<ClientSoftwareVersionMeta>(_collector, _writable, _version, clientSoftwareVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TApiVersionsRequestData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ClientSoftwareNameMeta>(_collector, _version, clientSoftwareName);
+    NPrivate::Size<ClientSoftwareVersionMeta>(_collector, _version, clientSoftwareVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TApiVersionsResponseData
+//
+const TApiVersionsResponseData::ErrorCodeMeta::Type TApiVersionsResponseData::ErrorCodeMeta::Default = 0;
+const TApiVersionsResponseData::ThrottleTimeMsMeta::Type TApiVersionsResponseData::ThrottleTimeMsMeta::Default = 0;
+const TApiVersionsResponseData::FinalizedFeaturesEpochMeta::Type TApiVersionsResponseData::FinalizedFeaturesEpochMeta::Default = -1;
+const TApiVersionsResponseData::ZkMigrationReadyMeta::Type TApiVersionsResponseData::ZkMigrationReadyMeta::Default = false;
+
+TApiVersionsResponseData::TApiVersionsResponseData() 
+        : errorCode(ErrorCodeMeta::Default)
+        , throttleTimeMs(ThrottleTimeMsMeta::Default)
+        , finalizedFeaturesEpoch(FinalizedFeaturesEpochMeta::Default)
+        , zkMigrationReady(ZkMigrationReadyMeta::Default)
+{}
+
+void TApiVersionsResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData";
+    }
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<ApiKeysMeta>(_readable, _version, apiKeys);
+    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+    NPrivate::Read<SupportedFeaturesMeta>(_readable, _version, supportedFeatures);
+    NPrivate::Read<FinalizedFeaturesEpochMeta>(_readable, _version, finalizedFeaturesEpoch);
+    NPrivate::Read<FinalizedFeaturesMeta>(_readable, _version, finalizedFeatures);
+    NPrivate::Read<ZkMigrationReadyMeta>(_readable, _version, zkMigrationReady);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                case SupportedFeaturesMeta::Tag:
+                    NPrivate::ReadTag<SupportedFeaturesMeta>(_readable, _version, supportedFeatures);
+                    break;
+                case FinalizedFeaturesEpochMeta::Tag:
+                    NPrivate::ReadTag<FinalizedFeaturesEpochMeta>(_readable, _version, finalizedFeaturesEpoch);
+                    break;
+                case FinalizedFeaturesMeta::Tag:
+                    NPrivate::ReadTag<FinalizedFeaturesMeta>(_readable, _version, finalizedFeatures);
+                    break;
+                case ZkMigrationReadyMeta::Tag:
+                    NPrivate::ReadTag<ZkMigrationReadyMeta>(_readable, _version, zkMigrationReady);
+                    break;
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TApiVersionsResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<ApiKeysMeta>(_collector, _writable, _version, apiKeys);
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    NPrivate::Write<SupportedFeaturesMeta>(_collector, _writable, _version, supportedFeatures);
+    NPrivate::Write<FinalizedFeaturesEpochMeta>(_collector, _writable, _version, finalizedFeaturesEpoch);
+    NPrivate::Write<FinalizedFeaturesMeta>(_collector, _writable, _version, finalizedFeatures);
+    NPrivate::Write<ZkMigrationReadyMeta>(_collector, _writable, _version, zkMigrationReady);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+        NPrivate::WriteTag<SupportedFeaturesMeta>(_writable, _version, supportedFeatures);
+        NPrivate::WriteTag<FinalizedFeaturesEpochMeta>(_writable, _version, finalizedFeaturesEpoch);
+        NPrivate::WriteTag<FinalizedFeaturesMeta>(_writable, _version, finalizedFeatures);
+        NPrivate::WriteTag<ZkMigrationReadyMeta>(_writable, _version, zkMigrationReady);
+    }
+}
+
+i32 TApiVersionsResponseData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<ApiKeysMeta>(_collector, _version, apiKeys);
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    NPrivate::Size<SupportedFeaturesMeta>(_collector, _version, supportedFeatures);
+    NPrivate::Size<FinalizedFeaturesEpochMeta>(_collector, _version, finalizedFeaturesEpoch);
+    NPrivate::Size<FinalizedFeaturesMeta>(_collector, _version, finalizedFeatures);
+    NPrivate::Size<ZkMigrationReadyMeta>(_collector, _version, zkMigrationReady);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TApiVersionsResponseData::TApiVersion
+//
+const TApiVersionsResponseData::TApiVersion::ApiKeyMeta::Type TApiVersionsResponseData::TApiVersion::ApiKeyMeta::Default = 0;
+const TApiVersionsResponseData::TApiVersion::MinVersionMeta::Type TApiVersionsResponseData::TApiVersion::MinVersionMeta::Default = 0;
+const TApiVersionsResponseData::TApiVersion::MaxVersionMeta::Type TApiVersionsResponseData::TApiVersion::MaxVersionMeta::Default = 0;
+
+TApiVersionsResponseData::TApiVersion::TApiVersion() 
+        : apiKey(ApiKeyMeta::Default)
+        , minVersion(MinVersionMeta::Default)
+        , maxVersion(MaxVersionMeta::Default)
+{}
+
+void TApiVersionsResponseData::TApiVersion::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TApiVersion";
+    }
+    NPrivate::Read<ApiKeyMeta>(_readable, _version, apiKey);
+    NPrivate::Read<MinVersionMeta>(_readable, _version, minVersion);
+    NPrivate::Read<MaxVersionMeta>(_readable, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TApiVersionsResponseData::TApiVersion::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TApiVersion";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ApiKeyMeta>(_collector, _writable, _version, apiKey);
+    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, minVersion);
+    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TApiVersionsResponseData::TApiVersion::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ApiKeyMeta>(_collector, _version, apiKey);
+    NPrivate::Size<MinVersionMeta>(_collector, _version, minVersion);
+    NPrivate::Size<MaxVersionMeta>(_collector, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TApiVersionsResponseData::TSupportedFeatureKey
+//
+const TApiVersionsResponseData::TSupportedFeatureKey::NameMeta::Type TApiVersionsResponseData::TSupportedFeatureKey::NameMeta::Default = {""};
+const TApiVersionsResponseData::TSupportedFeatureKey::MinVersionMeta::Type TApiVersionsResponseData::TSupportedFeatureKey::MinVersionMeta::Default = 0;
+const TApiVersionsResponseData::TSupportedFeatureKey::MaxVersionMeta::Type TApiVersionsResponseData::TSupportedFeatureKey::MaxVersionMeta::Default = 0;
+
+TApiVersionsResponseData::TSupportedFeatureKey::TSupportedFeatureKey() 
+        : name(NameMeta::Default)
+        , minVersion(MinVersionMeta::Default)
+        , maxVersion(MaxVersionMeta::Default)
+{}
+
+void TApiVersionsResponseData::TSupportedFeatureKey::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TSupportedFeatureKey";
+    }
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    NPrivate::Read<MinVersionMeta>(_readable, _version, minVersion);
+    NPrivate::Read<MaxVersionMeta>(_readable, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TApiVersionsResponseData::TSupportedFeatureKey::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TSupportedFeatureKey";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<MinVersionMeta>(_collector, _writable, _version, minVersion);
+    NPrivate::Write<MaxVersionMeta>(_collector, _writable, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TApiVersionsResponseData::TSupportedFeatureKey::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<MinVersionMeta>(_collector, _version, minVersion);
+    NPrivate::Size<MaxVersionMeta>(_collector, _version, maxVersion);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TApiVersionsResponseData::TFinalizedFeatureKey
+//
+const TApiVersionsResponseData::TFinalizedFeatureKey::NameMeta::Type TApiVersionsResponseData::TFinalizedFeatureKey::NameMeta::Default = {""};
+const TApiVersionsResponseData::TFinalizedFeatureKey::MaxVersionLevelMeta::Type TApiVersionsResponseData::TFinalizedFeatureKey::MaxVersionLevelMeta::Default = 0;
+const TApiVersionsResponseData::TFinalizedFeatureKey::MinVersionLevelMeta::Type TApiVersionsResponseData::TFinalizedFeatureKey::MinVersionLevelMeta::Default = 0;
+
+TApiVersionsResponseData::TFinalizedFeatureKey::TFinalizedFeatureKey() 
+        : name(NameMeta::Default)
+        , maxVersionLevel(MaxVersionLevelMeta::Default)
+        , minVersionLevel(MinVersionLevelMeta::Default)
+{}
+
+void TApiVersionsResponseData::TFinalizedFeatureKey::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TApiVersionsResponseData::TFinalizedFeatureKey";
+    }
+    NPrivate::Read<NameMeta>(_readable, _version, name);
+    NPrivate::Read<MaxVersionLevelMeta>(_readable, _version, maxVersionLevel);
+    NPrivate::Read<MinVersionLevelMeta>(_readable, _version, minVersionLevel);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TApiVersionsResponseData::TFinalizedFeatureKey::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TApiVersionsResponseData::TFinalizedFeatureKey";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<NameMeta>(_collector, _writable, _version, name);
+    NPrivate::Write<MaxVersionLevelMeta>(_collector, _writable, _version, maxVersionLevel);
+    NPrivate::Write<MinVersionLevelMeta>(_collector, _writable, _version, minVersionLevel);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TApiVersionsResponseData::TFinalizedFeatureKey::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<NameMeta>(_collector, _version, name);
+    NPrivate::Size<MaxVersionLevelMeta>(_collector, _version, maxVersionLevel);
+    NPrivate::Size<MinVersionLevelMeta>(_collector, _version, minVersionLevel);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TInitProducerIdRequestData
+//
+const TInitProducerIdRequestData::TransactionalIdMeta::Type TInitProducerIdRequestData::TransactionalIdMeta::Default = {""};
+const TInitProducerIdRequestData::TransactionTimeoutMsMeta::Type TInitProducerIdRequestData::TransactionTimeoutMsMeta::Default = 0;
+const TInitProducerIdRequestData::ProducerIdMeta::Type TInitProducerIdRequestData::ProducerIdMeta::Default = -1;
+const TInitProducerIdRequestData::ProducerEpochMeta::Type TInitProducerIdRequestData::ProducerEpochMeta::Default = -1;
+
+TInitProducerIdRequestData::TInitProducerIdRequestData() 
+        : transactionalId(TransactionalIdMeta::Default)
+        , transactionTimeoutMs(TransactionTimeoutMsMeta::Default)
+        , producerId(ProducerIdMeta::Default)
+        , producerEpoch(ProducerEpochMeta::Default)
+{}
+
+void TInitProducerIdRequestData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TInitProducerIdRequestData";
+    }
+    NPrivate::Read<TransactionalIdMeta>(_readable, _version, transactionalId);
+    NPrivate::Read<TransactionTimeoutMsMeta>(_readable, _version, transactionTimeoutMs);
+    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
+    NPrivate::Read<ProducerEpochMeta>(_readable, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TInitProducerIdRequestData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TInitProducerIdRequestData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<TransactionalIdMeta>(_collector, _writable, _version, transactionalId);
+    NPrivate::Write<TransactionTimeoutMsMeta>(_collector, _writable, _version, transactionTimeoutMs);
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
+    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TInitProducerIdRequestData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<TransactionalIdMeta>(_collector, _version, transactionalId);
+    NPrivate::Size<TransactionTimeoutMsMeta>(_collector, _version, transactionTimeoutMs);
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
+    NPrivate::Size<ProducerEpochMeta>(_collector, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+
+
+//
+// TInitProducerIdResponseData
+//
+const TInitProducerIdResponseData::ThrottleTimeMsMeta::Type TInitProducerIdResponseData::ThrottleTimeMsMeta::Default = 0;
+const TInitProducerIdResponseData::ErrorCodeMeta::Type TInitProducerIdResponseData::ErrorCodeMeta::Default = 0;
+const TInitProducerIdResponseData::ProducerIdMeta::Type TInitProducerIdResponseData::ProducerIdMeta::Default = -1;
+const TInitProducerIdResponseData::ProducerEpochMeta::Type TInitProducerIdResponseData::ProducerEpochMeta::Default = 0;
+
+TInitProducerIdResponseData::TInitProducerIdResponseData() 
+        : throttleTimeMs(ThrottleTimeMsMeta::Default)
+        , errorCode(ErrorCodeMeta::Default)
+        , producerId(ProducerIdMeta::Default)
+        , producerEpoch(ProducerEpochMeta::Default)
+{}
+
+void TInitProducerIdResponseData::Read(TKafkaReadable& _readable, TKafkaVersion _version) {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't read version " << _version << " of TInitProducerIdResponseData";
+    }
+    NPrivate::Read<ThrottleTimeMsMeta>(_readable, _version, throttleTimeMs);
+    NPrivate::Read<ErrorCodeMeta>(_readable, _version, errorCode);
+    NPrivate::Read<ProducerIdMeta>(_readable, _version, producerId);
+    NPrivate::Read<ProducerEpochMeta>(_readable, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        int _numTaggedFields = _readable.readUnsignedVarint();
+        for (int _i = 0; _i < _numTaggedFields; ++_i) {
+            int _tag = _readable.readUnsignedVarint();
+            int _size = _readable.readUnsignedVarint();
+            switch (_tag) {
+                default:
+                    _readable.skip(_size); // skip unknown tag
+                    break;
+            }
+        }
+    }
+}
+
+void TInitProducerIdResponseData::Write(TKafkaWritable& _writable, TKafkaVersion _version) const {
+    if (!NPrivate::VersionCheck<MessageMeta::PresentVersionMin, MessageMeta::PresentVersionMax>(_version)) {
+        ythrow yexception() << "Can't write version " << _version << " of TInitProducerIdResponseData";
+    }
+    NPrivate::TWriteCollector _collector;
+    NPrivate::Write<ThrottleTimeMsMeta>(_collector, _writable, _version, throttleTimeMs);
+    NPrivate::Write<ErrorCodeMeta>(_collector, _writable, _version, errorCode);
+    NPrivate::Write<ProducerIdMeta>(_collector, _writable, _version, producerId);
+    NPrivate::Write<ProducerEpochMeta>(_collector, _writable, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _writable.writeUnsignedVarint(_collector.NumTaggedFields);
+        
+    }
+}
+
+i32 TInitProducerIdResponseData::Size(TKafkaVersion _version) const {
+    NPrivate::TSizeCollector _collector;
+    NPrivate::Size<ThrottleTimeMsMeta>(_collector, _version, throttleTimeMs);
+    NPrivate::Size<ErrorCodeMeta>(_collector, _version, errorCode);
+    NPrivate::Size<ProducerIdMeta>(_collector, _version, producerId);
+    NPrivate::Size<ProducerEpochMeta>(_collector, _version, producerEpoch);
+    
+    if (NPrivate::VersionCheck<MessageMeta::FlexibleVersionMin, MessageMeta::FlexibleVersionMax>(_version)) {
+        _collector.Size += NPrivate::SizeOfUnsignedVarint(_collector.NumTaggedFields);
+    }
+    return _collector.Size;
+}
+} //namespace NKafka
diff --git a/ydb/core/kafkaproxy/kafka_messages.h b/ydb/core/kafkaproxy/kafka_messages.h
new file mode 100644
index 00000000000..ffa7052b361
--- /dev/null
+++ b/ydb/core/kafkaproxy/kafka_messages.h
@@ -0,0 +1,3245 @@
+
+// THIS CODE IS AUTOMATICALLY GENERATED.  DO NOT EDIT.
+// For generate it use kikimr/tools/kafka/generate.sh
+
+#pragma once
+
+#include "kafka_messages_int.h"
+
+namespace NKafka {
+
+enum EListenerType {
+    ZK_BROKER,
+    BROKER,
+    CONTROLLER,
+};
+
+enum EApiKey {
+    HEADER = -1, // [] 
+    PRODUCE = 0, // [ZK_BROKER, BROKER] 
+    FETCH = 1, // [ZK_BROKER, BROKER, CONTROLLER] 
+    METADATA = 3, // [ZK_BROKER, BROKER] 
+    API_VERSIONS = 18, // [ZK_BROKER, BROKER, CONTROLLER] 
+    INIT_PRODUCER_ID = 22, // [ZK_BROKER, BROKER] 
+};
+
+
+
+
+
+
+class TRequestHeaderData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 2;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TRequestHeaderData();
+    ~TRequestHeaderData() = default;
+    
+    struct RequestApiKeyMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "requestApiKey";
+        static constexpr const char* About = "The API key of this request.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    RequestApiKeyMeta::Type requestApiKey;
+    
+    struct RequestApiVersionMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "requestApiVersion";
+        static constexpr const char* About = "The API version of this request.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    RequestApiVersionMeta::Type requestApiVersion;
+    
+    struct CorrelationIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "correlationId";
+        static constexpr const char* About = "The correlation ID of this request.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    CorrelationIdMeta::Type correlationId;
+    
+    struct ClientIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "clientId";
+        static constexpr const char* About = "The client ID string.";
+        static const Type Default; // = {""};
+        
+        static constexpr TKafkaVersion PresentVersionMin = 1;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 1;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 0;
+        static constexpr TKafkaVersion FlexibleVersionMax = -1;
+    };
+    ClientIdMeta::Type clientId;
+    
+    
+    i16 ApiKey() const override { return HEADER; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TRequestHeaderData& other) const = default;
+};
+
+
+class TResponseHeaderData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 1;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TResponseHeaderData();
+    ~TResponseHeaderData() = default;
+    
+    struct CorrelationIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "correlationId";
+        static constexpr const char* About = "The correlation ID of this response.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 1;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    CorrelationIdMeta::Type correlationId;
+    
+    
+    i16 ApiKey() const override { return HEADER; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TResponseHeaderData& other) const = default;
+};
+
+
+class TProduceRequestData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 9;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TProduceRequestData();
+    ~TProduceRequestData() = default;
+    
+    class TTopicProduceData : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 9;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TTopicProduceData();
+        ~TTopicProduceData() = default;
+        
+        class TPartitionProduceData : public TMessage {
+        public:
+            struct MessageMeta {
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = 9;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            
+            TPartitionProduceData();
+            ~TPartitionProduceData() = default;
+            
+            struct IndexMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "index";
+                static constexpr const char* About = "The partition index.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            IndexMeta::Type index;
+            
+            struct RecordsMeta {
+                using Type = TKafkaRecords;
+                using TypeDesc = NPrivate::TKafkaRecordsDesc;
+                
+                static constexpr const char* Name = "records";
+                static constexpr const char* About = "The record data to be produced.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            RecordsMeta::Type records;
+            
+            
+            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+            i32 Size(TKafkaVersion version) const override;
+            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+            
+            bool operator==(const TPartitionProduceData& other) const = default;
+        };
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The topic name.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        struct PartitionDataMeta {
+            using Type = std::vector<TPartitionProduceData>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitionData";
+            static constexpr const char* About = "Each partition to produce to.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionDataMeta::Type partitionData;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TTopicProduceData& other) const = default;
+    };
+    
+    struct TransactionalIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "transactionalId";
+        static constexpr const char* About = "The transactional ID, or null if the producer is not transactional.";
+        static const Type Default; // = std::nullopt;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 3;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TransactionalIdMeta::Type transactionalId;
+    
+    struct AcksMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "acks";
+        static constexpr const char* About = "The number of acknowledgments the producer requires the leader to have received before considering a request complete. Allowed values: 0 for no acknowledgments, 1 for only the leader and -1 for the full ISR.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    AcksMeta::Type acks;
+    
+    struct TimeoutMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "timeoutMs";
+        static constexpr const char* About = "The timeout to await a response in milliseconds.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TimeoutMsMeta::Type timeoutMs;
+    
+    struct TopicDataMeta {
+        using Type = std::vector<TTopicProduceData>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "topicData";
+        static constexpr const char* About = "Each topic to produce to.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TopicDataMeta::Type topicData;
+    
+    
+    i16 ApiKey() const override { return PRODUCE; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TProduceRequestData& other) const = default;
+};
+
+
+class TProduceResponseData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 9;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TProduceResponseData();
+    ~TProduceResponseData() = default;
+    
+    class TTopicProduceResponse : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 9;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TTopicProduceResponse();
+        ~TTopicProduceResponse() = default;
+        
+        class TPartitionProduceResponse : public TMessage {
+        public:
+            struct MessageMeta {
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = 9;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            
+            TPartitionProduceResponse();
+            ~TPartitionProduceResponse() = default;
+            
+            class TBatchIndexAndErrorMessage : public TMessage {
+            public:
+                struct MessageMeta {
+                    static constexpr TKafkaVersion PresentVersionMin = 8;
+                    static constexpr TKafkaVersion PresentVersionMax = 9;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                
+                TBatchIndexAndErrorMessage();
+                ~TBatchIndexAndErrorMessage() = default;
+                
+                struct BatchIndexMeta {
+                    using Type = TKafkaInt32;
+                    using TypeDesc = NPrivate::TKafkaInt32Desc;
+                    
+                    static constexpr const char* Name = "batchIndex";
+                    static constexpr const char* About = "The batch index of the record that cause the batch to be dropped";
+                    static const Type Default; // = 0;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 8;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                BatchIndexMeta::Type batchIndex;
+                
+                struct BatchIndexErrorMessageMeta {
+                    using Type = TKafkaString;
+                    using TypeDesc = NPrivate::TKafkaStringDesc;
+                    
+                    static constexpr const char* Name = "batchIndexErrorMessage";
+                    static constexpr const char* About = "The error message of the record that caused the batch to be dropped";
+                    static const Type Default; // = std::nullopt;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 8;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 8;
+                    static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                BatchIndexErrorMessageMeta::Type batchIndexErrorMessage;
+                
+                
+                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+                i32 Size(TKafkaVersion version) const override;
+                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+                
+                bool operator==(const TBatchIndexAndErrorMessage& other) const = default;
+            };
+            
+            struct IndexMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "index";
+                static constexpr const char* About = "The partition index.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            IndexMeta::Type index;
+            
+            struct ErrorCodeMeta {
+                using Type = TKafkaInt16;
+                using TypeDesc = NPrivate::TKafkaInt16Desc;
+                
+                static constexpr const char* Name = "errorCode";
+                static constexpr const char* About = "The error code, or 0 if there was no error.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            ErrorCodeMeta::Type errorCode;
+            
+            struct BaseOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "baseOffset";
+                static constexpr const char* About = "The base offset.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            BaseOffsetMeta::Type baseOffset;
+            
+            struct LogAppendTimeMsMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "logAppendTimeMs";
+                static constexpr const char* About = "The timestamp returned by broker after appending the messages. If CreateTime is used for the topic, the timestamp will be -1.  If LogAppendTime is used for the topic, the timestamp will be the broker local time when the messages are appended.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 2;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LogAppendTimeMsMeta::Type logAppendTimeMs;
+            
+            struct LogStartOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "logStartOffset";
+                static constexpr const char* About = "The log start offset.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 5;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LogStartOffsetMeta::Type logStartOffset;
+            
+            struct RecordErrorsMeta {
+                using Type = std::vector<TBatchIndexAndErrorMessage>;
+                using TypeDesc = NPrivate::TKafkaArrayDesc;
+                
+                static constexpr const char* Name = "recordErrors";
+                static constexpr const char* About = "The batch indices of records that caused the batch to be dropped";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 8;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            RecordErrorsMeta::Type recordErrors;
+            
+            struct ErrorMessageMeta {
+                using Type = TKafkaString;
+                using TypeDesc = NPrivate::TKafkaStringDesc;
+                
+                static constexpr const char* Name = "errorMessage";
+                static constexpr const char* About = "The global error message summarizing the common root cause of the records that caused the batch to be dropped";
+                static const Type Default; // = std::nullopt;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 8;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 8;
+                static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            ErrorMessageMeta::Type errorMessage;
+            
+            
+            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+            i32 Size(TKafkaVersion version) const override;
+            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+            
+            bool operator==(const TPartitionProduceResponse& other) const = default;
+        };
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The topic name";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        struct PartitionResponsesMeta {
+            using Type = std::vector<TPartitionProduceResponse>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitionResponses";
+            static constexpr const char* About = "Each partition that we produced to within the topic.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionResponsesMeta::Type partitionResponses;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TTopicProduceResponse& other) const = default;
+    };
+    
+    struct ResponsesMeta {
+        using Type = std::vector<TTopicProduceResponse>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "responses";
+        static constexpr const char* About = "Each produce response";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ResponsesMeta::Type responses;
+    
+    struct ThrottleTimeMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "throttleTimeMs";
+        static constexpr const char* About = "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 1;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ThrottleTimeMsMeta::Type throttleTimeMs;
+    
+    
+    i16 ApiKey() const override { return PRODUCE; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TProduceResponseData& other) const = default;
+};
+
+
+class TFetchRequestData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 13;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TFetchRequestData();
+    ~TFetchRequestData() = default;
+    
+    class TFetchTopic : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 13;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TFetchTopic();
+        ~TFetchTopic() = default;
+        
+        class TFetchPartition : public TMessage {
+        public:
+            struct MessageMeta {
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = 13;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            
+            TFetchPartition();
+            ~TFetchPartition() = default;
+            
+            struct PartitionMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "partition";
+                static constexpr const char* About = "The partition index.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            PartitionMeta::Type partition;
+            
+            struct CurrentLeaderEpochMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "currentLeaderEpoch";
+                static constexpr const char* About = "The current leader epoch of the partition.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 9;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            CurrentLeaderEpochMeta::Type currentLeaderEpoch;
+            
+            struct FetchOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "fetchOffset";
+                static constexpr const char* About = "The message offset.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            FetchOffsetMeta::Type fetchOffset;
+            
+            struct LastFetchedEpochMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "lastFetchedEpoch";
+                static constexpr const char* About = "The epoch of the last fetched record or -1 if there is none";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 12;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LastFetchedEpochMeta::Type lastFetchedEpoch;
+            
+            struct LogStartOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "logStartOffset";
+                static constexpr const char* About = "The earliest available offset of the follower replica.  The field is only used when the request is sent by the follower.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 5;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LogStartOffsetMeta::Type logStartOffset;
+            
+            struct PartitionMaxBytesMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "partitionMaxBytes";
+                static constexpr const char* About = "The maximum bytes to fetch from this partition.  See KIP-74 for cases where this limit may not be honored.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            PartitionMaxBytesMeta::Type partitionMaxBytes;
+            
+            
+            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+            i32 Size(TKafkaVersion version) const override;
+            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+            
+            bool operator==(const TFetchPartition& other) const = default;
+        };
+        
+        struct TopicMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "topic";
+            static constexpr const char* About = "The name of the topic to fetch.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicMeta::Type topic;
+        
+        struct TopicIdMeta {
+            using Type = TKafkaUuid;
+            using TypeDesc = NPrivate::TKafkaUuidDesc;
+            
+            static constexpr const char* Name = "topicId";
+            static constexpr const char* About = "The unique topic ID";
+            static const Type Default; // = TKafkaUuid(0, 0);
+            
+            static constexpr TKafkaVersion PresentVersionMin = 13;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicIdMeta::Type topicId;
+        
+        struct PartitionsMeta {
+            using Type = std::vector<TFetchPartition>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitions";
+            static constexpr const char* About = "The partitions to fetch.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionsMeta::Type partitions;
+        
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TFetchTopic& other) const = default;
+    };
+    
+    class TForgottenTopic : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 7;
+            static constexpr TKafkaVersion PresentVersionMax = 13;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TForgottenTopic();
+        ~TForgottenTopic() = default;
+        
+        struct TopicMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "topic";
+            static constexpr const char* About = "The topic name.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 7;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicMeta::Type topic;
+        
+        struct TopicIdMeta {
+            using Type = TKafkaUuid;
+            using TypeDesc = NPrivate::TKafkaUuidDesc;
+            
+            static constexpr const char* Name = "topicId";
+            static constexpr const char* About = "The unique topic ID";
+            static const Type Default; // = TKafkaUuid(0, 0);
+            
+            static constexpr TKafkaVersion PresentVersionMin = 13;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicIdMeta::Type topicId;
+        
+        struct PartitionsMeta {
+            using Type = std::vector<TKafkaInt32>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitions";
+            static constexpr const char* About = "The partitions indexes to forget.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 7;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionsMeta::Type partitions;
+        
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TForgottenTopic& other) const = default;
+    };
+    
+    struct ClusterIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "clusterId";
+        static constexpr const char* About = "The clusterId if known. This is used to validate metadata fetches prior to broker registration.";
+        static constexpr const TKafkaInt32 Tag = 0;
+        static const Type Default; // = std::nullopt;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 12;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 12;
+        static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion NullableVersionMin = 12;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ClusterIdMeta::Type clusterId;
+    
+    struct ReplicaIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "replicaId";
+        static constexpr const char* About = "The broker ID of the follower, of -1 if this request is from a consumer.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ReplicaIdMeta::Type replicaId;
+    
+    struct MaxWaitMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "maxWaitMs";
+        static constexpr const char* About = "The maximum time in milliseconds to wait for the response.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    MaxWaitMsMeta::Type maxWaitMs;
+    
+    struct MinBytesMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "minBytes";
+        static constexpr const char* About = "The minimum bytes to accumulate in the response.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    MinBytesMeta::Type minBytes;
+    
+    struct MaxBytesMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "maxBytes";
+        static constexpr const char* About = "The maximum bytes to fetch.  See KIP-74 for cases where this limit may not be honored.";
+        static const Type Default; // = 0x7fffffff;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    MaxBytesMeta::Type maxBytes;
+    
+    struct IsolationLevelMeta {
+        using Type = TKafkaInt8;
+        using TypeDesc = NPrivate::TKafkaInt8Desc;
+        
+        static constexpr const char* Name = "isolationLevel";
+        static constexpr const char* About = "This setting controls the visibility of transactional records. Using READ_UNCOMMITTED (isolation_level = 0) makes all records visible. With READ_COMMITTED (isolation_level = 1), non-transactional and COMMITTED transactional records are visible. To be more concrete, READ_COMMITTED returns all data from offsets smaller than the current LSO (last stable offset), and enables the inclusion of the list of aborted transactions in the result, which allows consumers to discard ABORTED transactional records";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 4;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    IsolationLevelMeta::Type isolationLevel;
+    
+    struct SessionIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "sessionId";
+        static constexpr const char* About = "The fetch session ID.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 7;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    SessionIdMeta::Type sessionId;
+    
+    struct SessionEpochMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "sessionEpoch";
+        static constexpr const char* About = "The fetch session epoch, which is used for ordering requests in a session.";
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 7;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    SessionEpochMeta::Type sessionEpoch;
+    
+    struct TopicsMeta {
+        using Type = std::vector<TFetchTopic>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "topics";
+        static constexpr const char* About = "The topics to fetch.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TopicsMeta::Type topics;
+    
+    struct ForgottenTopicsDataMeta {
+        using Type = std::vector<TForgottenTopic>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "forgottenTopicsData";
+        static constexpr const char* About = "In an incremental fetch request, the partitions to remove.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 7;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ForgottenTopicsDataMeta::Type forgottenTopicsData;
+    
+    struct RackIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "rackId";
+        static constexpr const char* About = "Rack ID of the consumer making this request";
+        static const Type Default; // = {""};
+        
+        static constexpr TKafkaVersion PresentVersionMin = 11;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    RackIdMeta::Type rackId;
+    
+    
+    i16 ApiKey() const override { return FETCH; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TFetchRequestData& other) const = default;
+};
+
+
+class TFetchResponseData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 13;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TFetchResponseData();
+    ~TFetchResponseData() = default;
+    
+    class TFetchableTopicResponse : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 13;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TFetchableTopicResponse();
+        ~TFetchableTopicResponse() = default;
+        
+        class TPartitionData : public TMessage {
+        public:
+            struct MessageMeta {
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = 13;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            
+            TPartitionData();
+            ~TPartitionData() = default;
+            
+            class TEpochEndOffset : public TMessage {
+            public:
+                struct MessageMeta {
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = 13;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                
+                TEpochEndOffset();
+                ~TEpochEndOffset() = default;
+                
+                struct EpochMeta {
+                    using Type = TKafkaInt32;
+                    using TypeDesc = NPrivate::TKafkaInt32Desc;
+                    
+                    static constexpr const char* Name = "epoch";
+                    static constexpr const char* About = "";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                EpochMeta::Type epoch;
+                
+                struct EndOffsetMeta {
+                    using Type = TKafkaInt64;
+                    using TypeDesc = NPrivate::TKafkaInt64Desc;
+                    
+                    static constexpr const char* Name = "endOffset";
+                    static constexpr const char* About = "";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                EndOffsetMeta::Type endOffset;
+                
+                
+                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+                i32 Size(TKafkaVersion version) const override;
+                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+                
+                bool operator==(const TEpochEndOffset& other) const = default;
+            };
+            
+            class TLeaderIdAndEpoch : public TMessage {
+            public:
+                struct MessageMeta {
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = 13;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                
+                TLeaderIdAndEpoch();
+                ~TLeaderIdAndEpoch() = default;
+                
+                struct LeaderIdMeta {
+                    using Type = TKafkaInt32;
+                    using TypeDesc = NPrivate::TKafkaInt32Desc;
+                    
+                    static constexpr const char* Name = "leaderId";
+                    static constexpr const char* About = "The ID of the current leader or -1 if the leader is unknown.";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                LeaderIdMeta::Type leaderId;
+                
+                struct LeaderEpochMeta {
+                    using Type = TKafkaInt32;
+                    using TypeDesc = NPrivate::TKafkaInt32Desc;
+                    
+                    static constexpr const char* Name = "leaderEpoch";
+                    static constexpr const char* About = "The latest known leader epoch";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                LeaderEpochMeta::Type leaderEpoch;
+                
+                
+                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+                i32 Size(TKafkaVersion version) const override;
+                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+                
+                bool operator==(const TLeaderIdAndEpoch& other) const = default;
+            };
+            
+            class TSnapshotId : public TMessage {
+            public:
+                struct MessageMeta {
+                    static constexpr TKafkaVersion PresentVersionMin = 12;
+                    static constexpr TKafkaVersion PresentVersionMax = 13;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                
+                TSnapshotId();
+                ~TSnapshotId() = default;
+                
+                struct EndOffsetMeta {
+                    using Type = TKafkaInt64;
+                    using TypeDesc = NPrivate::TKafkaInt64Desc;
+                    
+                    static constexpr const char* Name = "endOffset";
+                    static constexpr const char* About = "";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                EndOffsetMeta::Type endOffset;
+                
+                struct EpochMeta {
+                    using Type = TKafkaInt32;
+                    using TypeDesc = NPrivate::TKafkaInt32Desc;
+                    
+                    static constexpr const char* Name = "epoch";
+                    static constexpr const char* About = "";
+                    static const Type Default; // = -1;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 0;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                EpochMeta::Type epoch;
+                
+                
+                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+                i32 Size(TKafkaVersion version) const override;
+                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+                
+                bool operator==(const TSnapshotId& other) const = default;
+            };
+            
+            class TAbortedTransaction : public TMessage {
+            public:
+                struct MessageMeta {
+                    static constexpr TKafkaVersion PresentVersionMin = 4;
+                    static constexpr TKafkaVersion PresentVersionMax = 13;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                
+                TAbortedTransaction();
+                ~TAbortedTransaction() = default;
+                
+                struct ProducerIdMeta {
+                    using Type = TKafkaInt64;
+                    using TypeDesc = NPrivate::TKafkaInt64Desc;
+                    
+                    static constexpr const char* Name = "producerId";
+                    static constexpr const char* About = "The producer id associated with the aborted transaction.";
+                    static const Type Default; // = 0;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 4;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                ProducerIdMeta::Type producerId;
+                
+                struct FirstOffsetMeta {
+                    using Type = TKafkaInt64;
+                    using TypeDesc = NPrivate::TKafkaInt64Desc;
+                    
+                    static constexpr const char* Name = "firstOffset";
+                    static constexpr const char* About = "The first offset in the aborted transaction.";
+                    static const Type Default; // = 0;
+                    
+                    static constexpr TKafkaVersion PresentVersionMin = 4;
+                    static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                    static constexpr TKafkaVersion TaggedVersionMin = 0;
+                    static constexpr TKafkaVersion TaggedVersionMax = -1;
+                    static constexpr TKafkaVersion NullableVersionMin = 0;
+                    static constexpr TKafkaVersion NullableVersionMax = -1;
+                    static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+                };
+                FirstOffsetMeta::Type firstOffset;
+                
+                
+                TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+                TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+                i32 Size(TKafkaVersion version) const override;
+                void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+                void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+                
+                bool operator==(const TAbortedTransaction& other) const = default;
+            };
+            
+            struct PartitionIndexMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "partitionIndex";
+                static constexpr const char* About = "The partition index.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            PartitionIndexMeta::Type partitionIndex;
+            
+            struct ErrorCodeMeta {
+                using Type = TKafkaInt16;
+                using TypeDesc = NPrivate::TKafkaInt16Desc;
+                
+                static constexpr const char* Name = "errorCode";
+                static constexpr const char* About = "The error code, or 0 if there was no fetch error.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            ErrorCodeMeta::Type errorCode;
+            
+            struct HighWatermarkMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "highWatermark";
+                static constexpr const char* About = "The current high water mark.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            HighWatermarkMeta::Type highWatermark;
+            
+            struct LastStableOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "lastStableOffset";
+                static constexpr const char* About = "The last stable offset (or LSO) of the partition. This is the last offset such that the state of all transactional records prior to this offset have been decided (ABORTED or COMMITTED)";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 4;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LastStableOffsetMeta::Type lastStableOffset;
+            
+            struct LogStartOffsetMeta {
+                using Type = TKafkaInt64;
+                using TypeDesc = NPrivate::TKafkaInt64Desc;
+                
+                static constexpr const char* Name = "logStartOffset";
+                static constexpr const char* About = "The current log start offset.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 5;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LogStartOffsetMeta::Type logStartOffset;
+            
+            struct DivergingEpochMeta {
+                using Type = TEpochEndOffset;
+                using TypeDesc = NPrivate::TKafkaStructDesc;
+                
+                static constexpr const char* Name = "divergingEpoch";
+                static constexpr const char* About = "In case divergence is detected based on the `LastFetchedEpoch` and `FetchOffset` in the request, this field indicates the largest epoch and its end offset such that subsequent records are known to diverge";
+                static constexpr const TKafkaInt32 Tag = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 12;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            DivergingEpochMeta::Type divergingEpoch;
+            
+            struct CurrentLeaderMeta {
+                using Type = TLeaderIdAndEpoch;
+                using TypeDesc = NPrivate::TKafkaStructDesc;
+                
+                static constexpr const char* Name = "currentLeader";
+                static constexpr const char* About = "";
+                static constexpr const TKafkaInt32 Tag = 1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 12;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            CurrentLeaderMeta::Type currentLeader;
+            
+            struct SnapshotIdMeta {
+                using Type = TSnapshotId;
+                using TypeDesc = NPrivate::TKafkaStructDesc;
+                
+                static constexpr const char* Name = "snapshotId";
+                static constexpr const char* About = "In the case of fetching an offset less than the LogStartOffset, this is the end offset and epoch that should be used in the FetchSnapshot request.";
+                static constexpr const TKafkaInt32 Tag = 2;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 12;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 12;
+                static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            SnapshotIdMeta::Type snapshotId;
+            
+            struct AbortedTransactionsMeta {
+                using Type = std::vector<TAbortedTransaction>;
+                using TypeDesc = NPrivate::TKafkaArrayDesc;
+                
+                static constexpr const char* Name = "abortedTransactions";
+                static constexpr const char* About = "The aborted transactions.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 4;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 4;
+                static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            AbortedTransactionsMeta::Type abortedTransactions;
+            
+            struct PreferredReadReplicaMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "preferredReadReplica";
+                static constexpr const char* About = "The preferred read replica for the consumer to use on its next fetch request";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 11;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            PreferredReadReplicaMeta::Type preferredReadReplica;
+            
+            struct RecordsMeta {
+                using Type = TKafkaRecords;
+                using TypeDesc = NPrivate::TKafkaRecordsDesc;
+                
+                static constexpr const char* Name = "records";
+                static constexpr const char* About = "The record data.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion FlexibleVersionMin = 12;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            RecordsMeta::Type records;
+            
+            
+            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+            i32 Size(TKafkaVersion version) const override;
+            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+            
+            bool operator==(const TPartitionData& other) const = default;
+        };
+        
+        struct TopicMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "topic";
+            static constexpr const char* About = "The topic name.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicMeta::Type topic;
+        
+        struct TopicIdMeta {
+            using Type = TKafkaUuid;
+            using TypeDesc = NPrivate::TKafkaUuidDesc;
+            
+            static constexpr const char* Name = "topicId";
+            static constexpr const char* About = "The unique topic ID";
+            static const Type Default; // = TKafkaUuid(0, 0);
+            
+            static constexpr TKafkaVersion PresentVersionMin = 13;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicIdMeta::Type topicId;
+        
+        struct PartitionsMeta {
+            using Type = std::vector<TPartitionData>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitions";
+            static constexpr const char* About = "The topic partitions.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 12;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionsMeta::Type partitions;
+        
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TFetchableTopicResponse& other) const = default;
+    };
+    
+    struct ThrottleTimeMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "throttleTimeMs";
+        static constexpr const char* About = "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 1;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ThrottleTimeMsMeta::Type throttleTimeMs;
+    
+    struct ErrorCodeMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "errorCode";
+        static constexpr const char* About = "The top level response error code.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 7;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ErrorCodeMeta::Type errorCode;
+    
+    struct SessionIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "sessionId";
+        static constexpr const char* About = "The fetch session ID, or 0 if this is not part of a fetch session.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 7;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    SessionIdMeta::Type sessionId;
+    
+    struct ResponsesMeta {
+        using Type = std::vector<TFetchableTopicResponse>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "responses";
+        static constexpr const char* About = "The response topics.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 12;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ResponsesMeta::Type responses;
+    
+    
+    i16 ApiKey() const override { return FETCH; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TFetchResponseData& other) const = default;
+};
+
+
+class TMetadataRequestData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 12;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TMetadataRequestData();
+    ~TMetadataRequestData() = default;
+    
+    class TMetadataRequestTopic : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TMetadataRequestTopic();
+        ~TMetadataRequestTopic() = default;
+        
+        struct TopicIdMeta {
+            using Type = TKafkaUuid;
+            using TypeDesc = NPrivate::TKafkaUuidDesc;
+            
+            static constexpr const char* Name = "topicId";
+            static constexpr const char* About = "The topic id.";
+            static const Type Default; // = TKafkaUuid(0, 0);
+            
+            static constexpr TKafkaVersion PresentVersionMin = 10;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicIdMeta::Type topicId;
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The topic name.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 10;
+            static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TMetadataRequestTopic& other) const = default;
+    };
+    
+    struct TopicsMeta {
+        using Type = std::vector<TMetadataRequestTopic>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "topics";
+        static constexpr const char* About = "The topics to fetch metadata for.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 1;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TopicsMeta::Type topics;
+    
+    struct AllowAutoTopicCreationMeta {
+        using Type = TKafkaBool;
+        using TypeDesc = NPrivate::TKafkaBoolDesc;
+        
+        static constexpr const char* Name = "allowAutoTopicCreation";
+        static constexpr const char* About = "If this is true, the broker may auto-create topics that we requested which do not already exist, if it is configured to do so.";
+        static const Type Default; // = true;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 4;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    AllowAutoTopicCreationMeta::Type allowAutoTopicCreation;
+    
+    struct IncludeClusterAuthorizedOperationsMeta {
+        using Type = TKafkaBool;
+        using TypeDesc = NPrivate::TKafkaBoolDesc;
+        
+        static constexpr const char* Name = "includeClusterAuthorizedOperations";
+        static constexpr const char* About = "Whether to include cluster authorized operations.";
+        static const Type Default; // = false;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 8;
+        static constexpr TKafkaVersion PresentVersionMax = 10;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    IncludeClusterAuthorizedOperationsMeta::Type includeClusterAuthorizedOperations;
+    
+    struct IncludeTopicAuthorizedOperationsMeta {
+        using Type = TKafkaBool;
+        using TypeDesc = NPrivate::TKafkaBoolDesc;
+        
+        static constexpr const char* Name = "includeTopicAuthorizedOperations";
+        static constexpr const char* About = "Whether to include topic authorized operations.";
+        static const Type Default; // = false;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 8;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    IncludeTopicAuthorizedOperationsMeta::Type includeTopicAuthorizedOperations;
+    
+    
+    i16 ApiKey() const override { return METADATA; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TMetadataRequestData& other) const = default;
+};
+
+
+class TMetadataResponseData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 12;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TMetadataResponseData();
+    ~TMetadataResponseData() = default;
+    
+    class TMetadataResponseBroker : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TMetadataResponseBroker();
+        ~TMetadataResponseBroker() = default;
+        
+        struct NodeIdMeta {
+            using Type = TKafkaInt32;
+            using TypeDesc = NPrivate::TKafkaInt32Desc;
+            
+            static constexpr const char* Name = "nodeId";
+            static constexpr const char* About = "The broker ID.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NodeIdMeta::Type nodeId;
+        
+        struct HostMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "host";
+            static constexpr const char* About = "The broker hostname.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        HostMeta::Type host;
+        
+        struct PortMeta {
+            using Type = TKafkaInt32;
+            using TypeDesc = NPrivate::TKafkaInt32Desc;
+            
+            static constexpr const char* Name = "port";
+            static constexpr const char* About = "The broker port.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PortMeta::Type port;
+        
+        struct RackMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "rack";
+            static constexpr const char* About = "The rack of the broker, or null if it has not been assigned to a rack.";
+            static const Type Default; // = std::nullopt;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 1;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 1;
+            static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        RackMeta::Type rack;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TMetadataResponseBroker& other) const = default;
+    };
+    
+    class TMetadataResponseTopic : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 12;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TMetadataResponseTopic();
+        ~TMetadataResponseTopic() = default;
+        
+        class TMetadataResponsePartition : public TMessage {
+        public:
+            struct MessageMeta {
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = 12;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            
+            TMetadataResponsePartition();
+            ~TMetadataResponsePartition() = default;
+            
+            struct ErrorCodeMeta {
+                using Type = TKafkaInt16;
+                using TypeDesc = NPrivate::TKafkaInt16Desc;
+                
+                static constexpr const char* Name = "errorCode";
+                static constexpr const char* About = "The partition error, or 0 if there was no error.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            ErrorCodeMeta::Type errorCode;
+            
+            struct PartitionIndexMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "partitionIndex";
+                static constexpr const char* About = "The partition index.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            PartitionIndexMeta::Type partitionIndex;
+            
+            struct LeaderIdMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "leaderId";
+                static constexpr const char* About = "The ID of the leader broker.";
+                static const Type Default; // = 0;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LeaderIdMeta::Type leaderId;
+            
+            struct LeaderEpochMeta {
+                using Type = TKafkaInt32;
+                using TypeDesc = NPrivate::TKafkaInt32Desc;
+                
+                static constexpr const char* Name = "leaderEpoch";
+                static constexpr const char* About = "The leader epoch of this partition.";
+                static const Type Default; // = -1;
+                
+                static constexpr TKafkaVersion PresentVersionMin = 7;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            LeaderEpochMeta::Type leaderEpoch;
+            
+            struct ReplicaNodesMeta {
+                using Type = std::vector<TKafkaInt32>;
+                using TypeDesc = NPrivate::TKafkaArrayDesc;
+                
+                static constexpr const char* Name = "replicaNodes";
+                static constexpr const char* About = "The set of all nodes that host this partition.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            ReplicaNodesMeta::Type replicaNodes;
+            
+            struct IsrNodesMeta {
+                using Type = std::vector<TKafkaInt32>;
+                using TypeDesc = NPrivate::TKafkaArrayDesc;
+                
+                static constexpr const char* Name = "isrNodes";
+                static constexpr const char* About = "The set of nodes that are in sync with the leader for this partition.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 0;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            IsrNodesMeta::Type isrNodes;
+            
+            struct OfflineReplicasMeta {
+                using Type = std::vector<TKafkaInt32>;
+                using TypeDesc = NPrivate::TKafkaArrayDesc;
+                
+                static constexpr const char* Name = "offlineReplicas";
+                static constexpr const char* About = "The set of offline replicas of this partition.";
+                
+                static constexpr TKafkaVersion PresentVersionMin = 5;
+                static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+                static constexpr TKafkaVersion TaggedVersionMin = 0;
+                static constexpr TKafkaVersion TaggedVersionMax = -1;
+                static constexpr TKafkaVersion NullableVersionMin = 0;
+                static constexpr TKafkaVersion NullableVersionMax = -1;
+                static constexpr TKafkaVersion FlexibleVersionMin = 9;
+                static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+            };
+            OfflineReplicasMeta::Type offlineReplicas;
+            
+            
+            TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+            TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+            i32 Size(TKafkaVersion version) const override;
+            void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+            void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+            
+            bool operator==(const TMetadataResponsePartition& other) const = default;
+        };
+        
+        struct ErrorCodeMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "errorCode";
+            static constexpr const char* About = "The topic error, or 0 if there was no error.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        ErrorCodeMeta::Type errorCode;
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The topic name.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 12;
+            static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        struct TopicIdMeta {
+            using Type = TKafkaUuid;
+            using TypeDesc = NPrivate::TKafkaUuidDesc;
+            
+            static constexpr const char* Name = "topicId";
+            static constexpr const char* About = "The topic id.";
+            static const Type Default; // = TKafkaUuid(0, 0);
+            
+            static constexpr TKafkaVersion PresentVersionMin = 10;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicIdMeta::Type topicId;
+        
+        struct IsInternalMeta {
+            using Type = TKafkaBool;
+            using TypeDesc = NPrivate::TKafkaBoolDesc;
+            
+            static constexpr const char* Name = "isInternal";
+            static constexpr const char* About = "True if the topic is internal.";
+            static const Type Default; // = false;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 1;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        IsInternalMeta::Type isInternal;
+        
+        struct PartitionsMeta {
+            using Type = std::vector<TMetadataResponsePartition>;
+            using TypeDesc = NPrivate::TKafkaArrayDesc;
+            
+            static constexpr const char* Name = "partitions";
+            static constexpr const char* About = "Each partition in the topic.";
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        PartitionsMeta::Type partitions;
+        
+        struct TopicAuthorizedOperationsMeta {
+            using Type = TKafkaInt32;
+            using TypeDesc = NPrivate::TKafkaInt32Desc;
+            
+            static constexpr const char* Name = "topicAuthorizedOperations";
+            static constexpr const char* About = "32-bit bitfield to represent authorized operations for this topic.";
+            static const Type Default; // = -2147483648;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 8;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 9;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        TopicAuthorizedOperationsMeta::Type topicAuthorizedOperations;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TMetadataResponseTopic& other) const = default;
+    };
+    
+    struct ThrottleTimeMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "throttleTimeMs";
+        static constexpr const char* About = "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ThrottleTimeMsMeta::Type throttleTimeMs;
+    
+    struct BrokersMeta {
+        using Type = std::vector<TMetadataResponseBroker>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "brokers";
+        static constexpr const char* About = "Each broker in the response.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    BrokersMeta::Type brokers;
+    
+    struct ClusterIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "clusterId";
+        static constexpr const char* About = "The cluster ID that responding broker belongs to.";
+        static const Type Default; // = std::nullopt;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 2;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 2;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ClusterIdMeta::Type clusterId;
+    
+    struct ControllerIdMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "controllerId";
+        static constexpr const char* About = "The ID of the controller broker.";
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 1;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ControllerIdMeta::Type controllerId;
+    
+    struct TopicsMeta {
+        using Type = std::vector<TMetadataResponseTopic>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "topics";
+        static constexpr const char* About = "Each topic in the response.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TopicsMeta::Type topics;
+    
+    struct ClusterAuthorizedOperationsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "clusterAuthorizedOperations";
+        static constexpr const char* About = "32-bit bitfield to represent authorized operations for this cluster.";
+        static const Type Default; // = -2147483648;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 8;
+        static constexpr TKafkaVersion PresentVersionMax = 10;
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 9;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ClusterAuthorizedOperationsMeta::Type clusterAuthorizedOperations;
+    
+    
+    i16 ApiKey() const override { return METADATA; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TMetadataResponseData& other) const = default;
+};
+
+
+class TApiVersionsRequestData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TApiVersionsRequestData();
+    ~TApiVersionsRequestData() = default;
+    
+    struct ClientSoftwareNameMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "clientSoftwareName";
+        static constexpr const char* About = "The name of the client.";
+        static const Type Default; // = {""};
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ClientSoftwareNameMeta::Type clientSoftwareName;
+    
+    struct ClientSoftwareVersionMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "clientSoftwareVersion";
+        static constexpr const char* About = "The version of the client.";
+        static const Type Default; // = {""};
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ClientSoftwareVersionMeta::Type clientSoftwareVersion;
+    
+    
+    i16 ApiKey() const override { return API_VERSIONS; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TApiVersionsRequestData& other) const = default;
+};
+
+
+class TApiVersionsResponseData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 3;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TApiVersionsResponseData();
+    ~TApiVersionsResponseData() = default;
+    
+    class TApiVersion : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TApiVersion();
+        ~TApiVersion() = default;
+        
+        struct ApiKeyMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "apiKey";
+            static constexpr const char* About = "The API index.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        ApiKeyMeta::Type apiKey;
+        
+        struct MinVersionMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "minVersion";
+            static constexpr const char* About = "The minimum supported version, inclusive.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MinVersionMeta::Type minVersion;
+        
+        struct MaxVersionMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "maxVersion";
+            static constexpr const char* About = "The maximum supported version, inclusive.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 0;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MaxVersionMeta::Type maxVersion;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TApiVersion& other) const = default;
+    };
+    
+    class TSupportedFeatureKey : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TSupportedFeatureKey();
+        ~TSupportedFeatureKey() = default;
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The name of the feature.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        struct MinVersionMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "minVersion";
+            static constexpr const char* About = "The minimum supported version for the feature.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MinVersionMeta::Type minVersion;
+        
+        struct MaxVersionMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "maxVersion";
+            static constexpr const char* About = "The maximum supported version for the feature.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MaxVersionMeta::Type maxVersion;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TSupportedFeatureKey& other) const = default;
+    };
+    
+    class TFinalizedFeatureKey : public TMessage {
+    public:
+        struct MessageMeta {
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = 3;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        
+        TFinalizedFeatureKey();
+        ~TFinalizedFeatureKey() = default;
+        
+        struct NameMeta {
+            using Type = TKafkaString;
+            using TypeDesc = NPrivate::TKafkaStringDesc;
+            
+            static constexpr const char* Name = "name";
+            static constexpr const char* About = "The name of the feature.";
+            static const Type Default; // = {""};
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        NameMeta::Type name;
+        
+        struct MaxVersionLevelMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "maxVersionLevel";
+            static constexpr const char* About = "The cluster-wide finalized max version level for the feature.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MaxVersionLevelMeta::Type maxVersionLevel;
+        
+        struct MinVersionLevelMeta {
+            using Type = TKafkaInt16;
+            using TypeDesc = NPrivate::TKafkaInt16Desc;
+            
+            static constexpr const char* Name = "minVersionLevel";
+            static constexpr const char* About = "The cluster-wide finalized min version level for the feature.";
+            static const Type Default; // = 0;
+            
+            static constexpr TKafkaVersion PresentVersionMin = 3;
+            static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+            static constexpr TKafkaVersion TaggedVersionMin = 0;
+            static constexpr TKafkaVersion TaggedVersionMax = -1;
+            static constexpr TKafkaVersion NullableVersionMin = 0;
+            static constexpr TKafkaVersion NullableVersionMax = -1;
+            static constexpr TKafkaVersion FlexibleVersionMin = 3;
+            static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+        };
+        MinVersionLevelMeta::Type minVersionLevel;
+        
+        i32 next;
+        i32 prev;
+        
+        TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+        TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+        i32 Size(TKafkaVersion version) const override;
+        void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+        void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+        
+        bool operator==(const TFinalizedFeatureKey& other) const = default;
+    };
+    
+    struct ErrorCodeMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "errorCode";
+        static constexpr const char* About = "The top-level error code.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ErrorCodeMeta::Type errorCode;
+    
+    struct ApiKeysMeta {
+        using Type = std::vector<TApiVersion>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "apiKeys";
+        static constexpr const char* About = "The APIs supported by the broker.";
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ApiKeysMeta::Type apiKeys;
+    
+    struct ThrottleTimeMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "throttleTimeMs";
+        static constexpr const char* About = "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 1;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ThrottleTimeMsMeta::Type throttleTimeMs;
+    
+    struct SupportedFeaturesMeta {
+        using Type = std::vector<TSupportedFeatureKey>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "supportedFeatures";
+        static constexpr const char* About = "Features supported by the broker.";
+        static constexpr const TKafkaInt32 Tag = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    SupportedFeaturesMeta::Type supportedFeatures;
+    
+    struct FinalizedFeaturesEpochMeta {
+        using Type = TKafkaInt64;
+        using TypeDesc = NPrivate::TKafkaInt64Desc;
+        
+        static constexpr const char* Name = "finalizedFeaturesEpoch";
+        static constexpr const char* About = "The monotonically increasing epoch for the finalized features information. Valid values are >= 0. A value of -1 is special and represents unknown epoch.";
+        static constexpr const TKafkaInt32 Tag = 1;
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    FinalizedFeaturesEpochMeta::Type finalizedFeaturesEpoch;
+    
+    struct FinalizedFeaturesMeta {
+        using Type = std::vector<TFinalizedFeatureKey>;
+        using TypeDesc = NPrivate::TKafkaArrayDesc;
+        
+        static constexpr const char* Name = "finalizedFeatures";
+        static constexpr const char* About = "List of cluster-wide finalized features. The information is valid only if FinalizedFeaturesEpoch >= 0.";
+        static constexpr const TKafkaInt32 Tag = 2;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    FinalizedFeaturesMeta::Type finalizedFeatures;
+    
+    struct ZkMigrationReadyMeta {
+        using Type = TKafkaBool;
+        using TypeDesc = NPrivate::TKafkaBoolDesc;
+        
+        static constexpr const char* Name = "zkMigrationReady";
+        static constexpr const char* About = "Set by a KRaft controller if the required configurations for ZK migration are present";
+        static constexpr const TKafkaInt32 Tag = 3;
+        static const Type Default; // = false;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 3;
+        static constexpr TKafkaVersion TaggedVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 3;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ZkMigrationReadyMeta::Type zkMigrationReady;
+    
+    
+    i16 ApiKey() const override { return API_VERSIONS; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TApiVersionsResponseData& other) const = default;
+};
+
+
+class TInitProducerIdRequestData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 4;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TInitProducerIdRequestData();
+    ~TInitProducerIdRequestData() = default;
+    
+    struct TransactionalIdMeta {
+        using Type = TKafkaString;
+        using TypeDesc = NPrivate::TKafkaStringDesc;
+        
+        static constexpr const char* Name = "transactionalId";
+        static constexpr const char* About = "The transactional id, or null if the producer is not transactional.";
+        static const Type Default; // = {""};
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TransactionalIdMeta::Type transactionalId;
+    
+    struct TransactionTimeoutMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "transactionTimeoutMs";
+        static constexpr const char* About = "The time in ms to wait before aborting idle transactions sent by this producer. This is only relevant if a TransactionalId has been defined.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    TransactionTimeoutMsMeta::Type transactionTimeoutMs;
+    
+    struct ProducerIdMeta {
+        using Type = TKafkaInt64;
+        using TypeDesc = NPrivate::TKafkaInt64Desc;
+        
+        static constexpr const char* Name = "producerId";
+        static constexpr const char* About = "The producer id. This is used to disambiguate requests if a transactional id is reused following its expiration.";
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ProducerIdMeta::Type producerId;
+    
+    struct ProducerEpochMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "producerEpoch";
+        static constexpr const char* About = "The producer's current epoch. This will be checked against the producer epoch on the broker, and the request will return an error if they do not match.";
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 3;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ProducerEpochMeta::Type producerEpoch;
+    
+    
+    i16 ApiKey() const override { return INIT_PRODUCER_ID; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TInitProducerIdRequestData& other) const = default;
+};
+
+
+class TInitProducerIdResponseData : public TApiMessage {
+public:
+    struct MessageMeta {
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = 4;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    
+    TInitProducerIdResponseData();
+    ~TInitProducerIdResponseData() = default;
+    
+    struct ThrottleTimeMsMeta {
+        using Type = TKafkaInt32;
+        using TypeDesc = NPrivate::TKafkaInt32Desc;
+        
+        static constexpr const char* Name = "throttleTimeMs";
+        static constexpr const char* About = "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ThrottleTimeMsMeta::Type throttleTimeMs;
+    
+    struct ErrorCodeMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "errorCode";
+        static constexpr const char* About = "The error code, or 0 if there was no error.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ErrorCodeMeta::Type errorCode;
+    
+    struct ProducerIdMeta {
+        using Type = TKafkaInt64;
+        using TypeDesc = NPrivate::TKafkaInt64Desc;
+        
+        static constexpr const char* Name = "producerId";
+        static constexpr const char* About = "The current producer id.";
+        static const Type Default; // = -1;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ProducerIdMeta::Type producerId;
+    
+    struct ProducerEpochMeta {
+        using Type = TKafkaInt16;
+        using TypeDesc = NPrivate::TKafkaInt16Desc;
+        
+        static constexpr const char* Name = "producerEpoch";
+        static constexpr const char* About = "The current epoch associated with the producer id.";
+        static const Type Default; // = 0;
+        
+        static constexpr TKafkaVersion PresentVersionMin = 0;
+        static constexpr TKafkaVersion PresentVersionMax = Max<TKafkaVersion>();
+        static constexpr TKafkaVersion TaggedVersionMin = 0;
+        static constexpr TKafkaVersion TaggedVersionMax = -1;
+        static constexpr TKafkaVersion NullableVersionMin = 0;
+        static constexpr TKafkaVersion NullableVersionMax = -1;
+        static constexpr TKafkaVersion FlexibleVersionMin = 2;
+        static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+    };
+    ProducerEpochMeta::Type producerEpoch;
+    
+    
+    i16 ApiKey() const override { return INIT_PRODUCER_ID; };
+    TKafkaVersion LowestSupportedVersion() const override { return MessageMeta::PresentVersionMin; };
+    TKafkaVersion HighestSupportedVersion() const override { return MessageMeta::PresentVersionMax; };
+    i32 Size(TKafkaVersion version) const override;
+    void Read(TKafkaReadable& readable, TKafkaVersion version) override;
+    void Write(TKafkaWritable& writable, TKafkaVersion version) const override;
+    
+    bool operator==(const TInitProducerIdResponseData& other) const = default;
+};
+
+} // namespace NKafka 
diff --git a/ydb/core/kafkaproxy/kafka_messages_int.cpp b/ydb/core/kafkaproxy/kafka_messages_int.cpp
new file mode 100644
index 00000000000..9604fdaa767
--- /dev/null
+++ b/ydb/core/kafkaproxy/kafka_messages_int.cpp
@@ -0,0 +1,84 @@
+#include "kafka_messages_int.h"
+
+namespace NKafka {
+
+void ErrorOnUnexpectedEnd(std::istream& is) {
+    if (is.eof()) {
+        ythrow yexception() << "unexpected end of stream";
+    }
+}
+
+TKafkaWritable& TKafkaWritable::operator<<(const TKafkaRawBytes& val) {
+    Os.write(val.data(), val.size());
+    return *this;
+}
+
+TKafkaWritable& TKafkaWritable::operator<<(const TKafkaRawString& val) {
+    Os.write(val.data(), val.length());
+    return *this;
+}
+
+TKafkaWritable& TKafkaWritable::operator<<(const TKafkaUuid& val) {
+    ui64 h = ui64(val >> (sizeof(ui64) << 3));
+    ui64 l = ui64(val);
+    *this << h << l;
+    return *this;
+}
+
+void TKafkaWritable::writeUnsignedVarint(TKafkaUint32 value) {
+    while ((value & 0xffffff80) != 0L) {
+        ui8 b = (ui8) ((value & 0x7f) | 0x80);
+        Os << b;
+        value >>= 7;
+    }
+    Os << (ui8) value;
+}
+
+TKafkaReadable& TKafkaReadable::operator>>(TKafkaUuid& val) {
+    ui64 h;
+    ui64 l;
+
+    *this >> h >> l;
+
+    val = TKafkaUuid(h, l);
+    return *this;
+}
+
+
+void TKafkaReadable::read(char* val, int length) {
+    Is.read(val, length);
+    ErrorOnUnexpectedEnd(Is);
+}
+
+ui32 TKafkaReadable::readUnsignedVarint() {
+    ui32 value = 0;
+    ui32 i = 0;
+    ui16 b;
+    while (((b = Is.get()) & 0x80) != 0) {
+        ErrorOnUnexpectedEnd(Is);
+
+        value |= ((ui32)(b & 0x7f)) << i;
+        i += 7;
+        if (i > 28) {
+            ythrow yexception() << "illegal varint length";
+        }
+    }
+
+    ErrorOnUnexpectedEnd(Is);
+
+    value |= b << i;
+    return value;
+}
+
+void TKafkaReadable::skip(int length) {
+    char buffer[64];
+    while (length) {
+        int l = std::min(length, 64);
+        Is.read(buffer, l);
+        length -= l;
+    }
+
+    ErrorOnUnexpectedEnd(Is);
+}
+
+} // namespace NKafka
diff --git a/ydb/core/kafkaproxy/kafka_messages_int.h b/ydb/core/kafkaproxy/kafka_messages_int.h
new file mode 100644
index 00000000000..f485cc5ebdd
--- /dev/null
+++ b/ydb/core/kafkaproxy/kafka_messages_int.h
@@ -0,0 +1,532 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include <util/generic/buffer.h>
+#include <util/generic/strbuf.h>
+
+#include <util/generic/array_ref.h>
+#include <util/generic/yexception.h>
+#include <util/system/types.h>
+
+#include <contrib/libs/cxxsupp/libcxx/include/type_traits>
+
+#include <ydb/library/yql/public/decimal/yql_wide_int.h>
+
+#include "kafka.h"
+
+namespace NKafka {
+namespace NPrivate {
+
+struct TKafkaBoolDesc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaInt8Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaInt16Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaUint16Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaInt32Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaUint32Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaInt64Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaUuidDesc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaFloat64Desc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = true;
+};
+
+struct TKafkaStringDesc {
+    static constexpr bool Default = true;
+    static constexpr bool Nullable = true;
+    static constexpr bool FixedLength = false;
+
+    static bool IsNull(const TKafkaString& value) { return !value; };
+};
+
+struct TKafkaStructDesc {
+    static constexpr bool Default = false;
+    static constexpr bool Nullable = false;
+    static constexpr bool FixedLength = false;
+};
+
+struct TKafkaBytesDesc {
+    static constexpr bool Default = false;
+    static constexpr bool Nullable = true;
+    static constexpr bool FixedLength = false;
+
+    static bool IsNull(const TKafkaBytes& value) { return !value; };
+};
+
+struct TKafkaRecordsDesc {
+    static constexpr bool Default = false;
+    static constexpr bool Nullable = true;
+    static constexpr bool FixedLength = false;
+
+    static bool IsNull(const TKafkaRecords& value) { return !value; };
+};
+
+struct TKafkaArrayDesc {
+    static constexpr bool Default = false;
+    static constexpr bool Nullable = true;
+    static constexpr bool FixedLength = false;
+
+    template<typename T>
+    static bool IsNull(const std::vector<T>& value) { return value.empty(); };
+};
+
+
+
+struct TWriteCollector {
+    ui32 NumTaggedFields = 0;
+};
+
+struct TSizeCollector {
+    ui32 Size = 0;
+    ui32 NumTaggedFields = 0;
+};
+
+
+
+constexpr i32 SizeOfUnsignedVarint(i32 value) {
+    int bytes = 1;
+    while ((value & 0xffffff80) != 0L) {
+        bytes += 1;
+        value >>= 7;
+    }
+    return bytes;
+}
+
+
+template<TKafkaVersion min, TKafkaVersion max>
+constexpr bool VersionAll() {
+    return 0 == min && max == Max<TKafkaVersion>();
+}
+
+template<TKafkaVersion min, TKafkaVersion max>
+constexpr bool VersionNone() {
+    return 0 == min && max == -1;
+}
+
+template<TKafkaVersion min, TKafkaVersion max>
+inline bool VersionCheck(const TKafkaVersion value) {
+    if constexpr (VersionNone<min, max>()) {
+        return false;
+    } else if constexpr (VersionAll<min, max>()) {
+        return true;
+    } else if constexpr (max == Max<TKafkaVersion>()) {
+        return min <= value;
+    } else if constexpr (min == 0) {
+        return value <= max;
+    } else {
+        return min <= value && value <= max;
+    }
+}
+
+
+
+template<typename Meta>
+bool IsDefaultValue(const typename Meta::Type& value) {
+    if constexpr (std::is_base_of_v<TMessage, typename Meta::Type>) {
+        typename Meta::Type defValue;
+        return defValue == value;
+    } else if constexpr (Meta::TypeDesc::Default) {
+        return Meta::Default == value;
+    } else if constexpr (Meta::TypeDesc::Nullable) {
+        return Meta::TypeDesc::IsNull(value);
+    } else {
+        return false;
+    }
+}
+
+
+
+template<TKafkaVersion FlexibleMin,
+         TKafkaVersion FlexibleMax>
+inline void WriteStringSize(TKafkaWritable& writable, TKafkaVersion version, TKafkaInt32 value) {
+    if (VersionCheck<FlexibleMin, FlexibleMax>(version)) {
+        writable.writeUnsignedVarint(value + 1);
+    } else {
+        writable << (TKafkaInt16)value;
+    }
+}
+
+template<TKafkaVersion FlexibleMin,
+         TKafkaVersion FlexibleMax>
+inline TKafkaInt32 ReadStringSize(TKafkaReadable& readable, TKafkaVersion version) {
+    if (VersionCheck<FlexibleMin, FlexibleMax>(version)) {
+        return readable.readUnsignedVarint() - 1;
+    } else {
+        TKafkaInt16 v;
+        readable >> v;
+        return v;
+    }
+}
+
+template<TKafkaVersion FlexibleMin,
+         TKafkaVersion FlexibleMax>
+inline void WriteArraySize(TKafkaWritable& writable, TKafkaVersion version, TKafkaInt32 value) {
+    if (VersionCheck<FlexibleMin, FlexibleMax>(version)) {
+        writable.writeUnsignedVarint(value + 1);
+    } else {
+        writable << value;
+    }
+}
+
+template<TKafkaVersion FlexibleMin,
+         TKafkaVersion FlexibleMax>
+inline TKafkaInt32 ReadArraySize(TKafkaReadable& readable, TKafkaVersion version) {
+    if (VersionCheck<FlexibleMin, FlexibleMax>(version)) {
+        return readable.readUnsignedVarint() - 1;
+    } else {
+        TKafkaInt32 v;
+        readable >> v;
+        return v;
+    }
+}
+
+
+
+//
+// Common
+//
+template<typename Meta,
+         typename TValueType>
+class TypeStrategy {
+public:
+    inline static void DoWrite(TKafkaWritable& writable, TKafkaVersion version, const TValueType& value) {
+        if constexpr (std::is_base_of_v<TMessage, TValueType>) {
+            value.Write(writable, version);
+        } else {
+            writable << value;
+        }
+    }
+
+    inline static void DoWriteTag(TKafkaWritable& writable, TKafkaVersion version, const TValueType& value) {
+        if constexpr (std::is_base_of_v<TMessage, TValueType>) {
+            value.Write(writable, version);
+        } else {
+            writable << value;
+        }
+    }
+
+    inline static void DoRead(TKafkaReadable& readable, TKafkaVersion version, TValueType& value) {
+        if constexpr (std::is_base_of_v<TMessage, TValueType>) {
+            value.Read(readable, version);
+        } else {
+            readable >> value;
+        }
+    }
+
+    inline static i64 DoSize(TKafkaVersion version, const TValueType& value) {
+        if constexpr (std::is_base_of_v<TMessage, TValueType>) {
+            return value.Size(version);
+        } else {
+            return sizeof(TValueType);
+        }
+    }
+};
+
+
+
+//
+// TKafkaString
+//
+template<typename Meta>
+class TypeStrategy<Meta, TKafkaString> {
+public:
+    inline static void DoWrite(TKafkaWritable& writable, TKafkaVersion version, const TKafkaString& value) {
+        if (value) {
+            const auto& v = *value;
+            if (v.length() > Max<i16>()) {
+                ythrow yexception() << "string field " << Meta::Name << " is too long to be serialized " << v.length();
+            }
+            WriteStringSize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(writable, version, v.length());
+            writable << v;
+        } else {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                WriteStringSize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(writable, version, -1);
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " serializing as null";
+            }
+        }
+    }
+
+    inline static void DoWriteTag(TKafkaWritable& writable, TKafkaVersion version, const TKafkaString& value) {
+        const auto& v = *value;
+        WriteStringSize<0, Max<TKafkaVersion>()>(writable, version, v.length());
+        writable << v;
+    }
+
+    inline static void DoRead(TKafkaReadable& readable, TKafkaVersion version, TKafkaString& value) {
+        TKafkaInt32 length = ReadStringSize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(readable, version);
+        if (length < 0) {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                value = std::nullopt;
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+            }
+        } else if (length > Max<i16>()){
+            ythrow yexception() << "string field " << Meta::Name << " had invalid length " << length;
+        } else {
+            value = TString();
+            value->ReserveAndResize(length);
+            readable.read(const_cast<char*>(value->data()), length);
+        }
+    }
+
+    inline static i64 DoSize(TKafkaVersion version, const TKafkaString& value) {
+        if (value) {
+            const auto& v = *value;
+            if (v.length() > Max<i16>()) {
+                ythrow yexception() << "string field " << Meta::Name << " is too long to be serialized " << v.length();
+            }
+            if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+                return v.length() + SizeOfUnsignedVarint(v.length() + sizeof(TKafkaInt8));
+            } else {
+                return v.length() + sizeof(TKafkaInt16);
+            }
+        } else {
+            if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+                return sizeof(TKafkaInt8);
+            } else {
+                return sizeof(TKafkaInt16);
+            }
+        }
+    }
+};
+
+
+//
+// TKafkaBytes
+//
+template<typename Meta>
+class TypeStrategy<Meta, TKafkaBytes> {
+public:
+    inline static void DoWrite(TKafkaWritable& writable, TKafkaVersion version, const TKafkaBytes& value) {
+        if (value) {
+            const auto& v = *value;
+            WriteArraySize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(writable, version, v.size());
+            writable << v;
+        } else {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                WriteArraySize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(writable, version, -1);
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " serializing as null";
+            }
+        }
+    }
+
+    inline static void DoWriteTag(TKafkaWritable& writable, TKafkaVersion version, const TKafkaBytes& value) {
+        const auto& v = *value;
+        WriteArraySize<0, Max<TKafkaVersion>()>(writable, version, v.size());
+        writable << v;
+    }
+
+    inline static void DoRead(TKafkaReadable& readable, TKafkaVersion version, TKafkaBytes& value) {
+        TKafkaInt32 length = ReadArraySize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(readable, version);
+        if (length < 0) {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                value = std::nullopt;
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+            }
+        } else {
+            value = TBuffer();
+            value->Resize(length);
+            readable.read(value->data(), length);
+        }
+    }
+
+    inline static i64 DoSize(TKafkaVersion version, const TKafkaBytes& value) {
+        if (value) {
+            const auto& v = *value;
+            if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+                return v.size() + SizeOfUnsignedVarint(v.size() + 1);
+            } else {
+                return v.size() + sizeof(TKafkaInt32);
+            }
+        } else {
+            if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+                return 1;
+            } else {
+                return sizeof(TKafkaInt32);
+            }
+        }
+    }
+};
+
+
+//
+// KafkaArray
+//
+template<typename Meta,
+         typename TValueType>
+class TypeStrategy<Meta, std::vector<TValueType>> {
+public:
+    inline static void DoWrite(TKafkaWritable& writable, TKafkaVersion version, const std::vector<TValueType>& value) {
+        WriteArraySize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(writable, version, value.size());
+
+        for(const auto& v : value) {
+            TypeStrategy<Meta, TValueType>::DoWrite(writable, version, v);
+        }
+    }
+
+    inline static void DoWriteTag(TKafkaWritable& writable, TKafkaVersion version, const std::vector<TValueType>& value) {
+        WriteArraySize<0, Max<TKafkaVersion>()>(writable, version, value.size());
+
+        for(const auto& v : value) {
+            TypeStrategy<Meta, TValueType>::DoWrite(writable, version, v);
+        }
+    }
+
+    inline static void DoRead(TKafkaReadable& readable, TKafkaVersion version, std::vector<TValueType>& value) {
+        TKafkaInt32 length = ReadArraySize<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(readable, version);
+        if (length < 0) {
+            if (VersionCheck<Meta::NullableVersionMin, Meta::NullableVersionMax>(version)) {
+                return;
+            } else {
+                ythrow yexception() << "non-nullable field " << Meta::Name << " was serialized as null";
+            }
+        }
+        value.resize(length);
+
+        for (int i = 0; i < length; ++i) {
+            TypeStrategy<Meta, TValueType>::DoRead(readable, version, value[i]);
+        }
+    }
+
+    inline static i64 DoSize(TKafkaVersion version, const std::vector<TValueType>& value) {
+        TKafkaInt32 size = 0;
+        if constexpr (Meta::TypeDesc::FixedLength) {
+            size = value.size() * sizeof(TValueType);
+        } else {
+            for(const auto& v : value) {
+                size += TypeStrategy<Meta, TValueType>::DoSize(version, v);
+            }
+        }
+        if (VersionCheck<Meta::FlexibleVersionMin, Meta::FlexibleVersionMax>(version)) {
+            return size + SizeOfUnsignedVarint(value.size() + 1);
+        } else {
+            return size + sizeof(TKafkaInt32);
+        }
+    }
+};
+
+
+
+//
+// Main fields function
+//
+template<typename Meta>
+inline void Write(TWriteCollector& collector, TKafkaWritable& writable, TKafkaInt16 version, const typename Meta::Type& value) {
+    if (VersionCheck<Meta::TaggedVersionMin, Meta::TaggedVersionMax>(version)) {
+        if (!IsDefaultValue<Meta>(value)) {
+            ++collector.NumTaggedFields;
+        }
+    } else if (VersionCheck<Meta::PresentVersionMin, Meta::PresentVersionMax>(version)) {
+        TypeStrategy<Meta, typename Meta::Type>::DoWrite(writable, version, value);
+    }
+}
+
+template<typename Meta>
+inline void Read(TKafkaReadable& readable, TKafkaInt16 version, typename Meta::Type& value) {
+    if (!VersionNone<Meta::TaggedVersionMin, Meta::TaggedVersionMax>() 
+        && VersionCheck<Meta::TaggedVersionMin, Meta::TaggedVersionMax>(version)) {
+        return;
+    } else {
+        if (VersionCheck<Meta::PresentVersionMin, Meta::PresentVersionMax>(version)) {
+            try {
+                TypeStrategy<Meta, typename Meta::Type>::DoRead(readable, version, value);
+            } catch (const yexception& e) {
+                ythrow yexception() << "error on read field " << Meta::Name << ": " << e.what();
+            }
+        } else if constexpr (Meta::TypeDesc::Default) {
+            value = Meta::Default;
+        }
+    }
+}
+
+template<typename Meta>
+inline void Size(TSizeCollector& collector, TKafkaInt16 version, const typename Meta::Type& value) {
+    if constexpr (!VersionNone<Meta::TaggedVersionMin, Meta::TaggedVersionMax>()) {
+        if (VersionCheck<Meta::TaggedVersionMin, Meta::TaggedVersionMax>(version)) {
+            if (!IsDefaultValue<Meta>(value)) {
+                ++collector.NumTaggedFields;
+
+                i64 size = TypeStrategy<Meta, typename Meta::Type>::DoSize(version, value);
+                collector.Size += size + SizeOfUnsignedVarint(Meta::Tag) + SizeOfUnsignedVarint(size); 
+            }
+        } else if (VersionCheck<Meta::PresentVersionMin, Meta::PresentVersionMax>(version)) {
+            collector.Size += TypeStrategy<Meta, typename Meta::Type>::DoSize(version, value);
+        }
+    } else {
+        if (VersionCheck<Meta::PresentVersionMin, Meta::PresentVersionMax>(version)) {
+            collector.Size += TypeStrategy<Meta, typename Meta::Type>::DoSize(version, value);
+        }
+    }
+}
+
+template<typename Meta>
+inline void WriteTag(TKafkaWritable& writable, TKafkaInt16 version, const typename Meta::Type& value) {
+    if constexpr (!VersionNone<Meta::TaggedVersionMin, Meta::TaggedVersionMax>()) {
+        if (VersionCheck<Meta::TaggedVersionMin, Meta::TaggedVersionMax>(version)) {
+            if (!IsDefaultValue<Meta>(value)) {
+                writable.writeUnsignedVarint(Meta::Tag);
+                writable.writeUnsignedVarint(TypeStrategy<Meta, typename Meta::Type>::DoSize(version, value));
+                TypeStrategy<Meta, typename Meta::Type>::DoWriteTag(writable, version, value);
+            }
+        }
+    }
+}
+
+template<typename Meta>
+inline void ReadTag(TKafkaReadable& readable, TKafkaInt16 version, typename Meta::Type& value) {
+    if constexpr (!VersionNone<Meta::TaggedVersionMin, Meta::TaggedVersionMax>()) {
+        TypeStrategy<Meta, typename Meta::Type>::DoRead(readable, version, value);
+    }
+}
+
+
+} // NPrivate
+
+} // namespace NKafka
diff --git a/ydb/core/kafkaproxy/ut/CMakeLists.darwin-x86_64.txt b/ydb/core/kafkaproxy/ut/CMakeLists.darwin-x86_64.txt
new file mode 100644
index 00000000000..5a13fbe24fe
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/CMakeLists.darwin-x86_64.txt
@@ -0,0 +1,53 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_executable(ydb-core-kafkaproxy-ut)
+target_link_libraries(ydb-core-kafkaproxy-ut PUBLIC
+  contrib-libs-cxxsupp
+  yutil
+  library-cpp-cpuid_check
+  cpp-testing-gtest
+  cpp-testing-gtest_main
+  ydb-core-kafkaproxy
+)
+target_link_options(ydb-core-kafkaproxy-ut PRIVATE
+  -Wl,-platform_version,macos,11.0,11.0
+  -fPIC
+  -fPIC
+  -framework
+  CoreFoundation
+)
+target_sources(ydb-core-kafkaproxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_serialization.cpp
+)
+add_test(
+  NAME
+  ydb-core-kafkaproxy-ut
+  COMMAND
+  ydb-core-kafkaproxy-ut
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  LABELS
+  SMALL
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  PROCESSORS
+  1
+)
+target_allocator(ydb-core-kafkaproxy-ut
+  system_allocator
+)
+vcs_info(ydb-core-kafkaproxy-ut)
diff --git a/ydb/core/kafkaproxy/ut/CMakeLists.linux-aarch64.txt b/ydb/core/kafkaproxy/ut/CMakeLists.linux-aarch64.txt
new file mode 100644
index 00000000000..c03a1c10ed9
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/CMakeLists.linux-aarch64.txt
@@ -0,0 +1,56 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_executable(ydb-core-kafkaproxy-ut)
+target_link_libraries(ydb-core-kafkaproxy-ut PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+  yutil
+  cpp-testing-gtest
+  cpp-testing-gtest_main
+  ydb-core-kafkaproxy
+)
+target_link_options(ydb-core-kafkaproxy-ut PRIVATE
+  -ldl
+  -lrt
+  -Wl,--no-as-needed
+  -fPIC
+  -fPIC
+  -lpthread
+  -lrt
+  -ldl
+)
+target_sources(ydb-core-kafkaproxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_serialization.cpp
+)
+add_test(
+  NAME
+  ydb-core-kafkaproxy-ut
+  COMMAND
+  ydb-core-kafkaproxy-ut
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  LABELS
+  SMALL
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  PROCESSORS
+  1
+)
+target_allocator(ydb-core-kafkaproxy-ut
+  cpp-malloc-jemalloc
+)
+vcs_info(ydb-core-kafkaproxy-ut)
diff --git a/ydb/core/kafkaproxy/ut/CMakeLists.linux-x86_64.txt b/ydb/core/kafkaproxy/ut/CMakeLists.linux-x86_64.txt
new file mode 100644
index 00000000000..9089cb74585
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/CMakeLists.linux-x86_64.txt
@@ -0,0 +1,58 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_executable(ydb-core-kafkaproxy-ut)
+target_link_libraries(ydb-core-kafkaproxy-ut PUBLIC
+  contrib-libs-linux-headers
+  contrib-libs-cxxsupp
+  yutil
+  library-cpp-cpuid_check
+  cpp-testing-gtest
+  cpp-testing-gtest_main
+  ydb-core-kafkaproxy
+)
+target_link_options(ydb-core-kafkaproxy-ut PRIVATE
+  -ldl
+  -lrt
+  -Wl,--no-as-needed
+  -fPIC
+  -fPIC
+  -lpthread
+  -lrt
+  -ldl
+)
+target_sources(ydb-core-kafkaproxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_serialization.cpp
+)
+add_test(
+  NAME
+  ydb-core-kafkaproxy-ut
+  COMMAND
+  ydb-core-kafkaproxy-ut
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  LABELS
+  SMALL
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  PROCESSORS
+  1
+)
+target_allocator(ydb-core-kafkaproxy-ut
+  cpp-malloc-tcmalloc
+  libs-tcmalloc-no_percpu_cache
+)
+vcs_info(ydb-core-kafkaproxy-ut)
diff --git a/ydb/core/kafkaproxy/ut/CMakeLists.txt b/ydb/core/kafkaproxy/ut/CMakeLists.txt
new file mode 100644
index 00000000000..f8b31df0c11
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/CMakeLists.txt
@@ -0,0 +1,17 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-aarch64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+  include(CMakeLists.darwin-x86_64.txt)
+elseif (WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL "AMD64" AND NOT HAVE_CUDA)
+  include(CMakeLists.windows-x86_64.txt)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT HAVE_CUDA)
+  include(CMakeLists.linux-x86_64.txt)
+endif()
diff --git a/ydb/core/kafkaproxy/ut/CMakeLists.windows-x86_64.txt b/ydb/core/kafkaproxy/ut/CMakeLists.windows-x86_64.txt
new file mode 100644
index 00000000000..1b948214ae1
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/CMakeLists.windows-x86_64.txt
@@ -0,0 +1,46 @@
+
+# This file was generated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_executable(ydb-core-kafkaproxy-ut)
+target_link_libraries(ydb-core-kafkaproxy-ut PUBLIC
+  contrib-libs-cxxsupp
+  yutil
+  library-cpp-cpuid_check
+  cpp-testing-gtest
+  cpp-testing-gtest_main
+  ydb-core-kafkaproxy
+)
+target_sources(ydb-core-kafkaproxy-ut PRIVATE
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/kafkaproxy/ut/ut_serialization.cpp
+)
+add_test(
+  NAME
+  ydb-core-kafkaproxy-ut
+  COMMAND
+  ydb-core-kafkaproxy-ut
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  LABELS
+  SMALL
+)
+set_property(
+  TEST
+  ydb-core-kafkaproxy-ut
+  PROPERTY
+  PROCESSORS
+  1
+)
+target_allocator(ydb-core-kafkaproxy-ut
+  system_allocator
+)
+vcs_info(ydb-core-kafkaproxy-ut)
diff --git a/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp b/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
new file mode 100644
index 00000000000..c66ba20a039
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/ut_kafka_functions.cpp
@@ -0,0 +1,29 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <strstream>
+
+#include "../kafka_messages.h"
+
+using namespace NKafka;
+
+const std::vector<i16> apiKeys {
+     PRODUCE,
+     FETCH,
+     METADATA,
+     API_VERSIONS,
+     INIT_PRODUCER_ID
+};
+
+TEST(Functions, CreateRequest) {
+    for(i16 apiKey : apiKeys) {
+        auto result = CreateRequest(apiKey);
+        EXPECT_EQ(result->ApiKey(), apiKey);
+    }
+}
+
+TEST(Functions, CreateResponse) {
+    for(i16 apiKey : apiKeys) {
+        auto result = CreateResponse(apiKey);
+        EXPECT_EQ(result->ApiKey(), apiKey);
+    }
+}
diff --git a/ydb/core/kafkaproxy/ut/ut_serialization.cpp b/ydb/core/kafkaproxy/ut/ut_serialization.cpp
new file mode 100644
index 00000000000..669799a35c0
--- /dev/null
+++ b/ydb/core/kafkaproxy/ut/ut_serialization.cpp
@@ -0,0 +1,671 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <strstream>
+
+#include "../kafka_messages.h"
+
+using namespace NKafka;
+
+void Print(std::stringstream& sb);
+
+TEST(Serialization, RequestHeader) {
+    std::stringstream sb;
+
+    TRequestHeaderData value;
+
+    value.requestApiKey = 3;
+    value.requestApiVersion = 7;
+    value.correlationId = 11;
+    value.clientId = { "clientId-value" };
+
+    TKafkaWritable writable(sb);
+    value.Write(writable, 1);
+
+    //Print(sb);
+
+    TRequestHeaderData result;
+
+    //sb.seekg(0);
+
+    TKafkaReadable readable(sb);
+    result.Read(readable, 1);
+
+    EXPECT_EQ(result.requestApiKey, 3);
+    EXPECT_EQ(result.requestApiVersion, 7);
+    EXPECT_EQ(result.correlationId, 11);
+    EXPECT_EQ(*result.clientId, "clientId-value");
+}
+
+TEST(Serialization, ResponseHeader) {
+    std::stringstream sb;
+
+    TResponseHeaderData value;
+
+    value.correlationId = 13;
+
+    TKafkaWritable writable(sb);
+    value.Write(writable, 0);
+
+    //Print(sb);
+
+    TResponseHeaderData result;
+
+    TKafkaReadable readable(sb);
+    result.Read(readable, 0);
+
+    EXPECT_EQ(result.correlationId, 13);
+}
+
+TEST(Serialization, ApiVersionsRequest) {
+    std::stringstream sb;
+
+    TApiVersionsRequestData value;
+
+    value.clientSoftwareName = { "apache-kafka-java" };
+    value.clientSoftwareVersion = { "3.4.0" };
+
+    TKafkaWritable writable(sb);
+    value.Write(writable, 3);
+
+    //Print(sb);
+
+    TApiVersionsRequestData result;
+
+    TKafkaReadable readable(sb);
+    result.Read(readable, 3);
+
+    EXPECT_EQ(*result.clientSoftwareName, "apache-kafka-java");
+    EXPECT_EQ(*result.clientSoftwareVersion, "3.4.0");
+}
+
+TEST(Serialization, ApiVersionsResponse) {
+    TString longString = "long-string-value-0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; 
+
+    std::stringstream sb;
+
+    TApiVersionsResponseData value;
+
+    value.errorCode = 7;
+
+    {
+        TApiVersionsResponseData::TApiVersion version;
+        version.apiKey = 11;
+        version.minVersion = 13;
+        version.maxVersion = 17;
+
+        value.apiKeys.push_back(version);
+    }
+    {
+        TApiVersionsResponseData::TApiVersion version;
+        version.apiKey = 33;
+        version.minVersion = 37;
+        version.maxVersion = 41;
+
+        value.apiKeys.push_back(version);
+    }
+
+    TApiVersionsResponseData::TFinalizedFeatureKey finalizeFeature;
+    finalizeFeature.name = { longString };
+    finalizeFeature.maxVersionLevel = 19;
+    finalizeFeature.minVersionLevel = 23;
+
+    value.finalizedFeatures.push_back(finalizeFeature);
+    value.finalizedFeaturesEpoch = 29;
+
+    value.throttleTimeMs = 31;
+    value.zkMigrationReady = true;
+
+    TKafkaWritable writable(sb);
+    value.Write(writable, 3);
+
+    TApiVersionsResponseData result;
+
+    TKafkaReadable readable(sb);
+    result.Read(readable, 3);
+
+    EXPECT_EQ(result.errorCode, 7);
+    EXPECT_EQ(result.apiKeys.size(), 2ul);
+    EXPECT_EQ(result.apiKeys[0].apiKey, 11);
+    EXPECT_EQ(result.apiKeys[0].minVersion, 13);
+    EXPECT_EQ(result.apiKeys[0].maxVersion, 17);
+    EXPECT_EQ(result.apiKeys[1].apiKey, 33);
+    EXPECT_EQ(result.apiKeys[1].minVersion, 37);
+    EXPECT_EQ(result.apiKeys[1].maxVersion, 41);
+    EXPECT_EQ(result.finalizedFeatures.size(), 1ul);
+    EXPECT_EQ(*result.finalizedFeatures[0].name, longString);
+    EXPECT_EQ(result.finalizedFeatures[0].maxVersionLevel, 19);
+    EXPECT_EQ(result.finalizedFeatures[0].minVersionLevel, 23);
+    EXPECT_EQ(result.finalizedFeaturesEpoch, 29l);
+    EXPECT_EQ(result.throttleTimeMs, 31);
+    EXPECT_EQ(result.zkMigrationReady, true);
+}
+
+TEST(Serialization, ProduceRequest) {
+    char data0[] = "it-is produce data message 1";
+    char data1[] = "it-is produce data other message 2";
+
+    std::stringstream sb;
+
+    TProduceRequestData value;
+
+    value.transactionalId = { "transactional-id-value-123456" };
+    value.acks = 3;
+    value.timeoutMs = 5;
+    value.topicData.resize(2);
+    value.topicData[0].name = "/it/is/some/topic/name";
+    value.topicData[0].partitionData.resize(2);
+    value.topicData[0].partitionData[0].index = 0;
+    value.topicData[0].partitionData[0].records = { TBuffer(data0, sizeof(data0)) };
+    value.topicData[0].partitionData[1].index = 1;
+    value.topicData[0].partitionData[1].records = {};
+    value.topicData[1].name = "/it/is/other/topic/name";
+    value.topicData[1].partitionData.resize(1);
+    value.topicData[1].partitionData[0].index = 0;
+    value.topicData[1].partitionData[0].records = { TBuffer(data1, sizeof(data1)) };
+
+    TKafkaWritable writable(sb);
+    value.Write(writable, 3);
+
+    TProduceRequestData result;
+
+    TKafkaReadable readable(sb);
+    result.Read(readable, 3);
+
+    EXPECT_TRUE(result.transactionalId);
+    EXPECT_EQ(*result.transactionalId, "transactional-id-value-123456" );
+    EXPECT_EQ(result.acks, 3);
+    EXPECT_EQ(result.timeoutMs, 5);
+    EXPECT_EQ(result.topicData.size(), 2ul);
+    EXPECT_TRUE(result.topicData[0].name);
+    EXPECT_EQ(*result.topicData[0].name, "/it/is/some/topic/name");
+    EXPECT_EQ(result.topicData[0].partitionData.size(), 2ul);
+    EXPECT_EQ(result.topicData[0].partitionData[0].index, 0);
+    EXPECT_TRUE(result.topicData[0].partitionData[0].records);
+    EXPECT_EQ(*result.topicData[0].partitionData[0].records, TBuffer(data0, sizeof(data0)));
+    EXPECT_EQ(result.topicData[0].partitionData[1].index, 1);
+    EXPECT_EQ(result.topicData[0].partitionData[1].records, std::nullopt);
+    EXPECT_TRUE(result.topicData[1].name);
+    EXPECT_EQ(*result.topicData[1].name, "/it/is/other/topic/name");
+    EXPECT_EQ(result.topicData[1].partitionData.size(), 1ul);
+    EXPECT_EQ(result.topicData[1].partitionData[0].index, 0);
+    EXPECT_TRUE(result.topicData[1].partitionData[0].records);
+    EXPECT_EQ(*result.topicData[1].partitionData[0].records, TBuffer(data1, sizeof(data1)));
+}
+
+
+TEST(Serialization, UnsignedVarint) {
+    std::vector<ui32> values = {0, 1, 127, 128, 32191};
+
+    for(ui32 v : values) {
+        std::stringstream sb;
+        TKafkaWritable writable(sb);
+        TKafkaReadable redable(sb);
+
+        writable.writeUnsignedVarint(v);
+        ui32 r = redable.readUnsignedVarint();
+        EXPECT_EQ(r, v);
+    }
+}
+
+#define SIMPLE_HEAD(Type_, Value)                   \
+    Meta_##Type_::Type value = Value;               \
+    Meta_##Type_::Type result;                      \
+                                                    \
+    std::stringstream sb;                           \
+    TKafkaWritable writable(sb);                    \
+    TKafkaReadable readable(sb);                    \
+                                                    \
+    Y_UNUSED(readable);                             \
+    Y_UNUSED(result);                               \
+                                                    \
+    NKafka::NPrivate::TWriteCollector collector;
+
+
+
+struct Meta_TKafkaInt8 {
+    using Type = TKafkaInt8;
+    using TypeDesc = NKafka::NPrivate::TKafkaInt8Desc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+    static const Type Default; // = 7;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+const Meta_TKafkaInt8::Type Meta_TKafkaInt8::Default = 7;
+
+TEST(Serialization, TKafkaInt8_NotPresentVersion) {
+    SIMPLE_HEAD(TKafkaInt8, 37);
+
+    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 0, value);
+    sb.get();
+    EXPECT_TRUE(sb.eof()); // For version 0 value is not serializable. Stream must be empty
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+
+    NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 0, result);
+    EXPECT_EQ(result, Meta_TKafkaInt8::Default); // For version 0 value is not serializable
+}
+
+TEST(Serialization, TKafkaInt8_PresentVersion_NotTaggedVersion) {
+    SIMPLE_HEAD(TKafkaInt8, 37);
+
+    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 3, value);
+    NKafka::NPrivate::Read<Meta_TKafkaInt8>(readable, 3, result);
+
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion) {
+    SIMPLE_HEAD(TKafkaInt8, 37);
+
+    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 1u);
+
+    NKafka::NPrivate::WriteTag<Meta_TKafkaInt8>(writable, 11, value);
+
+    i32 tag = readable.readUnsignedVarint();
+    EXPECT_EQ(tag, Meta_TKafkaInt8::Tag);
+
+    ui32 size = readable.readUnsignedVarint();
+    EXPECT_EQ(size, sizeof(TKafkaInt8));
+
+    NKafka::NPrivate::ReadTag<Meta_TKafkaInt8>(readable, 11, result);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaInt8_PresentVersion_TaggedVersion_Default) {
+    SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
+
+    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+}
+
+
+struct Meta_TKafkaStruct {
+    using Type = TRequestHeaderData;
+    using TypeDesc = NKafka::NPrivate::TKafkaStructDesc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+    static const Type Default; // = 7;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+TEST(Serialization, Struct_IsDefault) {
+    TRequestHeaderData value;
+    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // all fields have default values
+
+    value.requestApiKey = 123;
+    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaStruct>(value)); // field changed
+}
+
+
+struct Meta_TKafkaString {
+    using Type = TKafkaString;
+    using TypeDesc = NKafka::NPrivate::TKafkaStringDesc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+    static const Type Default; // = 7;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+const Meta_TKafkaString::Type Meta_TKafkaString::Default = "default_value";
+
+TEST(Serialization, TKafkaString_IsDefault) {
+    TKafkaString value;
+    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // std::nullopt != "default_value"
+
+    value = "random_string";
+    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value)); // "random_string" != "default_value"
+
+    value = "default_value";
+    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaString>(value));
+}
+
+TEST(Serialization, TKafkaString_PresentVersion_NotTaggedVersion) {
+    SIMPLE_HEAD(TKafkaString, { "some value" });
+
+    NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 3, value);
+    NKafka::NPrivate::Read<Meta_TKafkaString>(readable, 3, result);
+
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion) {
+    SIMPLE_HEAD(TKafkaString, { "some value" });
+
+    NKafka::NPrivate::Write<Meta_TKafkaString>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 1u);
+
+    NKafka::NPrivate::WriteTag<Meta_TKafkaString>(writable, 11, value);
+
+    i32 tag = readable.readUnsignedVarint();
+    EXPECT_EQ(tag, Meta_TKafkaString::Tag);
+
+    ui32 size = readable.readUnsignedVarint();
+    EXPECT_EQ(size, value->size() + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1)); // "+1" because serialized as unsigned int, and null serialized with size equals 0
+
+    NKafka::NPrivate::ReadTag<Meta_TKafkaString>(readable, 11, result);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaString_PresentVersion_TaggedVersion_Default) {
+    SIMPLE_HEAD(TKafkaInt8, Meta_TKafkaInt8::Default);
+
+    NKafka::NPrivate::Write<Meta_TKafkaInt8>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+}
+
+
+
+struct Meta_TKafkaArray {
+    using Type = std::vector<TKafkaString>;
+    using TypeDesc = NKafka::NPrivate::TKafkaArrayDesc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+TEST(Serialization, TKafkaArray_IsDefault) {
+    Meta_TKafkaArray::Type value;
+    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array is empty
+
+    value.push_back("random_string");
+    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaArray>(value)); // array contains elements
+}
+
+TEST(Serialization, TKafkaArray_PresentVersion_NotTaggedVersion) {
+    SIMPLE_HEAD(TKafkaArray, { "some value" });
+
+    NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 3, value);
+    NKafka::NPrivate::Read<Meta_TKafkaArray>(readable, 3, result);
+
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion) {
+    TString v = "some value";
+    SIMPLE_HEAD(TKafkaArray, { v });
+
+    NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 1u);
+
+    NKafka::NPrivate::WriteTag<Meta_TKafkaArray>(writable, 11, value);
+
+    i32 tag = readable.readUnsignedVarint();
+    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
+
+    ui32 size = readable.readUnsignedVarint();
+    EXPECT_EQ(size, v.length() // array element data
+        + NKafka::NPrivate::SizeOfUnsignedVarint(value.size()) // array size
+        + NKafka::NPrivate::SizeOfUnsignedVarint(v.length() + 1) // string size. +1 because null string serialize as 0-length
+    );
+
+    NKafka::NPrivate::ReadTag<Meta_TKafkaArray>(readable, 11, result);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaArray_PresentVersion_TaggedVersion_Default) {
+    SIMPLE_HEAD(TKafkaArray, {});
+
+    NKafka::NPrivate::Write<Meta_TKafkaArray>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+}
+
+
+
+struct Meta_TKafkaBytes {
+    using Type = TKafkaBytes;
+    using TypeDesc = NKafka::NPrivate::TKafkaBytesDesc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+TEST(Serialization, TKafkaBytes_IsDefault) {
+    Meta_TKafkaBytes::Type value;
+    EXPECT_TRUE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is std::nullopt
+
+    value = TBuffer();
+    value->Resize(10);
+    EXPECT_FALSE(NKafka::NPrivate::IsDefaultValue<Meta_TKafkaBytes>(value)); // value is not null
+}
+
+TEST(Serialization, TKafkaBytes_PresentVersion_NotTaggedVersion) {
+    SIMPLE_HEAD(TKafkaBytes, TBuffer("0123456789", 10));
+
+    NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 3, value);
+    NKafka::NPrivate::Read<Meta_TKafkaBytes>(readable, 3, result);
+
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion) {
+    SIMPLE_HEAD(TKafkaBytes, TBuffer("0123456789", 10));
+
+    NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 1u);
+
+    NKafka::NPrivate::WriteTag<Meta_TKafkaBytes>(writable, 11, value);
+
+    i32 tag = readable.readUnsignedVarint();
+    EXPECT_EQ(tag, Meta_TKafkaArray::Tag);
+
+    ui32 size = readable.readUnsignedVarint();
+    EXPECT_EQ(size, value->size() // byffer data
+        + NKafka::NPrivate::SizeOfUnsignedVarint(value->size() + 1) // buffer size. +1 because null value stored as size 0
+    );
+
+    NKafka::NPrivate::ReadTag<Meta_TKafkaBytes>(readable, 11, result);
+    EXPECT_EQ(result, value); // Must read same that write
+}
+
+TEST(Serialization, TKafkaBytes_PresentVersion_TaggedVersion_Default) {
+    SIMPLE_HEAD(TKafkaBytes, std::nullopt);
+
+    NKafka::NPrivate::Write<Meta_TKafkaBytes>(collector, writable, 11, value);
+    EXPECT_EQ(collector.NumTaggedFields, 0u); // not serialize default value for tagged version
+}
+
+
+TEST(Serialization, TRequestHeaderData_reference) {
+    // original kafka serialized value (java implementation)
+    ui8 reference[] = {0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x10, 0x63, 0x6C, 0x69, 0x65, 0x6E, 0x74, 0x2D, 0x69, 0x64, 0x2D, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x00};
+
+    std::stringstream sb;
+    TKafkaWritable writable(sb);
+    TKafkaReadable readable(sb);
+
+    TRequestHeaderData value;
+    value.requestApiKey = 3;
+    value.requestApiVersion = 7;
+    value.correlationId = 13;
+    value.clientId = "client-id-string";
+
+    value.Write(writable, 2);
+
+    for(ui8 r : reference) {
+        ui8 v = sb.get();
+        EXPECT_EQ(v, r);
+    }
+
+    sb.write((char*)reference, sizeof(reference));
+
+    TRequestHeaderData result;
+    result.Read(readable, 2);
+    EXPECT_EQ(result.requestApiKey, 3);
+    EXPECT_EQ(result.requestApiVersion, 7);
+    EXPECT_EQ(result.correlationId, 13);
+    EXPECT_EQ(result.clientId, "client-id-string");
+}
+
+struct Meta_TKafkaFloat64 {
+    using Type = TKafkaFloat64;
+    using TypeDesc = NKafka::NPrivate::TKafkaFloat64Desc;
+
+    static constexpr const char* Name = "value";
+    static constexpr const char* About = "The test field.";
+    static constexpr const TKafkaInt32 Tag = 31;
+    static const Type Default; // = 7;
+                
+    static constexpr TKafkaVersion PresentVersionMin = 3;
+    static constexpr TKafkaVersion PresentVersionMax = 97;
+    static constexpr TKafkaVersion TaggedVersionMin = 11;
+    static constexpr TKafkaVersion TaggedVersionMax = 17;
+    static constexpr TKafkaVersion NullableVersionMin = 5;
+    static constexpr TKafkaVersion NullableVersionMax = 19;
+    static constexpr TKafkaVersion FlexibleVersionMin = 7;
+    static constexpr TKafkaVersion FlexibleVersionMax = Max<TKafkaVersion>();
+};
+
+const Meta_TKafkaFloat64::Type Meta_TKafkaFloat64::Default = 7.875;
+
+TEST(Serialization, TKafkaFloat64_PresentVersion_NotTaggedVersion) {
+    // original kafka serialized value (java implementation)
+    ui8 reference[] = {0x40, 0x09, 0x21, 0xCA, 0xC0, 0x83, 0x12, 0x6F};
+
+    SIMPLE_HEAD(TKafkaFloat64, 3.1415);
+
+    NKafka::NPrivate::Write<Meta_TKafkaFloat64>(collector, writable, 3, value);
+    NKafka::NPrivate::Read<Meta_TKafkaFloat64>(readable, 3, result);
+
+    EXPECT_EQ(collector.NumTaggedFields, 0u);
+    EXPECT_EQ(result, value); // Must read same that write
+
+    NKafka::NPrivate::Write<Meta_TKafkaFloat64>(collector, writable, 3, value);
+    for(ui8 r : reference) {
+        ui8 v = sb.get();
+        EXPECT_EQ(v, r);
+    }
+}
+
+TEST(Serialization, ProduceRequestData_reference) {
+    // original kafka serialized value (java implementation)
+    ui8 reference[] = {0x02, 0x37, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x03, 0x0D, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74,
+                       0x69, 0x6F, 0x6E, 0x2D, 0x31, 0x31, 0x04, 0x00, 0x00, 0x00, 0x0D, 0x1C, 0x72, 0x65, 0x63, 0x6F,
+                       0x72, 0x64, 0x2D, 0x31, 0x33, 0x2D, 0x69, 0x74, 0x2D, 0x69, 0x73, 0x2D, 0x6B, 0x61, 0x66, 0x6B,
+                       0x61, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x11, 0x1C, 0x72, 0x65, 0x63,
+                       0x6F, 0x72, 0x64, 0x2D, 0x31, 0x37, 0x2D, 0x69, 0x74, 0x2D, 0x69, 0x73, 0x2D, 0x6B, 0x61, 0x66,
+                       0x6B, 0x61, 0x2D, 0x62, 0x79, 0x74, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                       0x0D, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6F, 0x6E, 0x2D, 0x32, 0x33, 0x01, 0x00, 0x00};
+
+    std::stringstream sb;
+    TKafkaWritable writable(sb);
+    TKafkaReadable readable(sb);
+
+    TProduceRequestData value;
+    value.acks = 3;
+    value.timeoutMs = 5;
+    value.transactionalId = "7";
+
+    value.topicData.resize(2);
+    value.topicData[0].name = "partition-11";
+    value.topicData[0].partitionData.resize(3);
+    value.topicData[0].partitionData[0].index = 13;
+    value.topicData[0].partitionData[0].records = TKafkaRawBytes("record-13-it-is-kafka-bytes", 27);
+    value.topicData[0].partitionData[1].index = 17;
+    value.topicData[0].partitionData[1].records = TKafkaRawBytes("record-17-it-is-kafka-bytes", 27);
+
+    value.topicData[1].name = "partition-23";
+
+    value.Write(writable, 9);
+
+//    Print(sb);
+
+    for(ui8 r : reference) {
+        ui8 v = sb.get();
+        EXPECT_EQ(v, r);
+    }
+
+    sb.write((char*)reference, sizeof(reference));
+
+    TProduceRequestData result;
+    result.Read(readable, 9);
+
+    EXPECT_EQ(result.acks, 3);
+    EXPECT_EQ(result.timeoutMs, 5);
+    EXPECT_EQ(result.transactionalId, "7");
+
+    EXPECT_EQ(result.topicData.size(), 2ul);
+    EXPECT_EQ(result.topicData[0].name, "partition-11");
+    EXPECT_EQ(result.topicData[0].partitionData.size(), 3ul);
+    EXPECT_EQ(result.topicData[0].partitionData[0].index, 13);
+    EXPECT_EQ(result.topicData[0].partitionData[0].records, TKafkaRawBytes("record-13-it-is-kafka-bytes", 27));
+    EXPECT_EQ(result.topicData[0].partitionData[1].index, 17);
+    EXPECT_EQ(result.topicData[0].partitionData[1].records, TKafkaRawBytes("record-17-it-is-kafka-bytes", 27));
+    EXPECT_EQ(result.topicData[0].partitionData[2].index, 0);
+    EXPECT_EQ(result.topicData[0].partitionData[2].records, std::nullopt);
+
+    EXPECT_EQ(result.topicData[1].name, "partition-23");
+    EXPECT_EQ(result.topicData[1].partitionData.size(), 0ul);
+}
+
+
+char Hex(const unsigned char c) {
+    return c < 10 ? '0' + c : 'A' + c - 10;
+}
+
+void Print(std::stringstream& sb) {
+    while(true) {
+        char c = sb.get();
+        if (sb.eof()) {
+            break;
+        }
+        Cerr << ", 0x" << Hex(c >> 4) << Hex(c & 0x0F);
+    }
+    Cerr << Endl;
+
+    sb.seekg(-sb.tellg());
+}