// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: flwr/proto/recordset.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2frecordset_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2frecordset_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3018000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3018001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_flwr_2fproto_2frecordset_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_flwr_2fproto_2frecordset_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[17]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_flwr_2fproto_2frecordset_2eproto;
namespace flwr {
namespace proto {
class Array;
struct ArrayDefaultTypeInternal;
extern ArrayDefaultTypeInternal _Array_default_instance_;
class BoolList;
struct BoolListDefaultTypeInternal;
extern BoolListDefaultTypeInternal _BoolList_default_instance_;
class BytesList;
struct BytesListDefaultTypeInternal;
extern BytesListDefaultTypeInternal _BytesList_default_instance_;
class ConfigsRecord;
struct ConfigsRecordDefaultTypeInternal;
extern ConfigsRecordDefaultTypeInternal _ConfigsRecord_default_instance_;
class ConfigsRecordValue;
struct ConfigsRecordValueDefaultTypeInternal;
extern ConfigsRecordValueDefaultTypeInternal _ConfigsRecordValue_default_instance_;
class ConfigsRecord_DataEntry_DoNotUse;
struct ConfigsRecord_DataEntry_DoNotUseDefaultTypeInternal;
extern ConfigsRecord_DataEntry_DoNotUseDefaultTypeInternal _ConfigsRecord_DataEntry_DoNotUse_default_instance_;
class DoubleList;
struct DoubleListDefaultTypeInternal;
extern DoubleListDefaultTypeInternal _DoubleList_default_instance_;
class MetricsRecord;
struct MetricsRecordDefaultTypeInternal;
extern MetricsRecordDefaultTypeInternal _MetricsRecord_default_instance_;
class MetricsRecordValue;
struct MetricsRecordValueDefaultTypeInternal;
extern MetricsRecordValueDefaultTypeInternal _MetricsRecordValue_default_instance_;
class MetricsRecord_DataEntry_DoNotUse;
struct MetricsRecord_DataEntry_DoNotUseDefaultTypeInternal;
extern MetricsRecord_DataEntry_DoNotUseDefaultTypeInternal _MetricsRecord_DataEntry_DoNotUse_default_instance_;
class ParametersRecord;
struct ParametersRecordDefaultTypeInternal;
extern ParametersRecordDefaultTypeInternal _ParametersRecord_default_instance_;
class RecordSet;
struct RecordSetDefaultTypeInternal;
extern RecordSetDefaultTypeInternal _RecordSet_default_instance_;
class RecordSet_ConfigsEntry_DoNotUse;
struct RecordSet_ConfigsEntry_DoNotUseDefaultTypeInternal;
extern RecordSet_ConfigsEntry_DoNotUseDefaultTypeInternal _RecordSet_ConfigsEntry_DoNotUse_default_instance_;
class RecordSet_MetricsEntry_DoNotUse;
struct RecordSet_MetricsEntry_DoNotUseDefaultTypeInternal;
extern RecordSet_MetricsEntry_DoNotUseDefaultTypeInternal _RecordSet_MetricsEntry_DoNotUse_default_instance_;
class RecordSet_ParametersEntry_DoNotUse;
struct RecordSet_ParametersEntry_DoNotUseDefaultTypeInternal;
extern RecordSet_ParametersEntry_DoNotUseDefaultTypeInternal _RecordSet_ParametersEntry_DoNotUse_default_instance_;
class Sint64List;
struct Sint64ListDefaultTypeInternal;
extern Sint64ListDefaultTypeInternal _Sint64List_default_instance_;
class StringList;
struct StringListDefaultTypeInternal;
extern StringListDefaultTypeInternal _StringList_default_instance_;
}  // namespace proto
}  // namespace flwr
PROTOBUF_NAMESPACE_OPEN
template<> ::flwr::proto::Array* Arena::CreateMaybeMessage<::flwr::proto::Array>(Arena*);
template<> ::flwr::proto::BoolList* Arena::CreateMaybeMessage<::flwr::proto::BoolList>(Arena*);
template<> ::flwr::proto::BytesList* Arena::CreateMaybeMessage<::flwr::proto::BytesList>(Arena*);
template<> ::flwr::proto::ConfigsRecord* Arena::CreateMaybeMessage<::flwr::proto::ConfigsRecord>(Arena*);
template<> ::flwr::proto::ConfigsRecordValue* Arena::CreateMaybeMessage<::flwr::proto::ConfigsRecordValue>(Arena*);
template<> ::flwr::proto::ConfigsRecord_DataEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ConfigsRecord_DataEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::DoubleList* Arena::CreateMaybeMessage<::flwr::proto::DoubleList>(Arena*);
template<> ::flwr::proto::MetricsRecord* Arena::CreateMaybeMessage<::flwr::proto::MetricsRecord>(Arena*);
template<> ::flwr::proto::MetricsRecordValue* Arena::CreateMaybeMessage<::flwr::proto::MetricsRecordValue>(Arena*);
template<> ::flwr::proto::MetricsRecord_DataEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::MetricsRecord_DataEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ParametersRecord* Arena::CreateMaybeMessage<::flwr::proto::ParametersRecord>(Arena*);
template<> ::flwr::proto::RecordSet* Arena::CreateMaybeMessage<::flwr::proto::RecordSet>(Arena*);
template<> ::flwr::proto::RecordSet_ConfigsEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::RecordSet_ConfigsEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::RecordSet_MetricsEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::RecordSet_MetricsEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::RecordSet_ParametersEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::RecordSet_ParametersEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::Sint64List* Arena::CreateMaybeMessage<::flwr::proto::Sint64List>(Arena*);
template<> ::flwr::proto::StringList* Arena::CreateMaybeMessage<::flwr::proto::StringList>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace flwr {
namespace proto {

// ===================================================================

class DoubleList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.DoubleList) */ {
 public:
  inline DoubleList() : DoubleList(nullptr) {}
  ~DoubleList() override;
  explicit constexpr DoubleList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DoubleList(const DoubleList& from);
  DoubleList(DoubleList&& from) noexcept
    : DoubleList() {
    *this = ::std::move(from);
  }

  inline DoubleList& operator=(const DoubleList& from) {
    CopyFrom(from);
    return *this;
  }
  inline DoubleList& operator=(DoubleList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DoubleList& default_instance() {
    return *internal_default_instance();
  }
  static inline const DoubleList* internal_default_instance() {
    return reinterpret_cast<const DoubleList*>(
               &_DoubleList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DoubleList& a, DoubleList& b) {
    a.Swap(&b);
  }
  inline void Swap(DoubleList* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DoubleList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline DoubleList* New() const final {
    return new DoubleList();
  }

  DoubleList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DoubleList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DoubleList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DoubleList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DoubleList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.DoubleList";
  }
  protected:
  explicit DoubleList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated double vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  double _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_vals() const;
  void _internal_add_vals(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_vals();
  public:
  double vals(int index) const;
  void set_vals(int index, double value);
  void add_vals(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_vals();

  // @@protoc_insertion_point(class_scope:flwr.proto.DoubleList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > vals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class Sint64List final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.Sint64List) */ {
 public:
  inline Sint64List() : Sint64List(nullptr) {}
  ~Sint64List() override;
  explicit constexpr Sint64List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Sint64List(const Sint64List& from);
  Sint64List(Sint64List&& from) noexcept
    : Sint64List() {
    *this = ::std::move(from);
  }

  inline Sint64List& operator=(const Sint64List& from) {
    CopyFrom(from);
    return *this;
  }
  inline Sint64List& operator=(Sint64List&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Sint64List& default_instance() {
    return *internal_default_instance();
  }
  static inline const Sint64List* internal_default_instance() {
    return reinterpret_cast<const Sint64List*>(
               &_Sint64List_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Sint64List& a, Sint64List& b) {
    a.Swap(&b);
  }
  inline void Swap(Sint64List* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Sint64List* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Sint64List* New() const final {
    return new Sint64List();
  }

  Sint64List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Sint64List>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Sint64List& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Sint64List& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Sint64List* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Sint64List";
  }
  protected:
  explicit Sint64List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated sint64 vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_vals() const;
  void _internal_add_vals(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_vals();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 vals(int index) const;
  void set_vals(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_vals(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_vals();

  // @@protoc_insertion_point(class_scope:flwr.proto.Sint64List)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > vals_;
  mutable std::atomic<int> _vals_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class BoolList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.BoolList) */ {
 public:
  inline BoolList() : BoolList(nullptr) {}
  ~BoolList() override;
  explicit constexpr BoolList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BoolList(const BoolList& from);
  BoolList(BoolList&& from) noexcept
    : BoolList() {
    *this = ::std::move(from);
  }

  inline BoolList& operator=(const BoolList& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolList& operator=(BoolList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoolList& default_instance() {
    return *internal_default_instance();
  }
  static inline const BoolList* internal_default_instance() {
    return reinterpret_cast<const BoolList*>(
               &_BoolList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(BoolList& a, BoolList& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolList* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BoolList* New() const final {
    return new BoolList();
  }

  BoolList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BoolList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BoolList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const BoolList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.BoolList";
  }
  protected:
  explicit BoolList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated bool vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  bool _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_vals() const;
  void _internal_add_vals(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_vals();
  public:
  bool vals(int index) const;
  void set_vals(int index, bool value);
  void add_vals(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_vals();

  // @@protoc_insertion_point(class_scope:flwr.proto.BoolList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > vals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class StringList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.StringList) */ {
 public:
  inline StringList() : StringList(nullptr) {}
  ~StringList() override;
  explicit constexpr StringList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StringList(const StringList& from);
  StringList(StringList&& from) noexcept
    : StringList() {
    *this = ::std::move(from);
  }

  inline StringList& operator=(const StringList& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringList& operator=(StringList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StringList& default_instance() {
    return *internal_default_instance();
  }
  static inline const StringList* internal_default_instance() {
    return reinterpret_cast<const StringList*>(
               &_StringList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(StringList& a, StringList& b) {
    a.Swap(&b);
  }
  inline void Swap(StringList* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StringList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline StringList* New() const final {
    return new StringList();
  }

  StringList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StringList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StringList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const StringList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.StringList";
  }
  protected:
  explicit StringList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated string vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  const std::string& vals(int index) const;
  std::string* mutable_vals(int index);
  void set_vals(int index, const std::string& value);
  void set_vals(int index, std::string&& value);
  void set_vals(int index, const char* value);
  void set_vals(int index, const char* value, size_t size);
  std::string* add_vals();
  void add_vals(const std::string& value);
  void add_vals(std::string&& value);
  void add_vals(const char* value);
  void add_vals(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_vals();
  private:
  const std::string& _internal_vals(int index) const;
  std::string* _internal_add_vals();
  public:

  // @@protoc_insertion_point(class_scope:flwr.proto.StringList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> vals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class BytesList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.BytesList) */ {
 public:
  inline BytesList() : BytesList(nullptr) {}
  ~BytesList() override;
  explicit constexpr BytesList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BytesList(const BytesList& from);
  BytesList(BytesList&& from) noexcept
    : BytesList() {
    *this = ::std::move(from);
  }

  inline BytesList& operator=(const BytesList& from) {
    CopyFrom(from);
    return *this;
  }
  inline BytesList& operator=(BytesList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BytesList& default_instance() {
    return *internal_default_instance();
  }
  static inline const BytesList* internal_default_instance() {
    return reinterpret_cast<const BytesList*>(
               &_BytesList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(BytesList& a, BytesList& b) {
    a.Swap(&b);
  }
  inline void Swap(BytesList* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BytesList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline BytesList* New() const final {
    return new BytesList();
  }

  BytesList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BytesList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BytesList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const BytesList& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BytesList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.BytesList";
  }
  protected:
  explicit BytesList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValsFieldNumber = 1,
  };
  // repeated bytes vals = 1;
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  const std::string& vals(int index) const;
  std::string* mutable_vals(int index);
  void set_vals(int index, const std::string& value);
  void set_vals(int index, std::string&& value);
  void set_vals(int index, const char* value);
  void set_vals(int index, const void* value, size_t size);
  std::string* add_vals();
  void add_vals(const std::string& value);
  void add_vals(std::string&& value);
  void add_vals(const char* value);
  void add_vals(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_vals();
  private:
  const std::string& _internal_vals(int index) const;
  std::string* _internal_add_vals();
  public:

  // @@protoc_insertion_point(class_scope:flwr.proto.BytesList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> vals_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class Array final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.Array) */ {
 public:
  inline Array() : Array(nullptr) {}
  ~Array() override;
  explicit constexpr Array(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Array(const Array& from);
  Array(Array&& from) noexcept
    : Array() {
    *this = ::std::move(from);
  }

  inline Array& operator=(const Array& from) {
    CopyFrom(from);
    return *this;
  }
  inline Array& operator=(Array&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Array& default_instance() {
    return *internal_default_instance();
  }
  static inline const Array* internal_default_instance() {
    return reinterpret_cast<const Array*>(
               &_Array_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Array& a, Array& b) {
    a.Swap(&b);
  }
  inline void Swap(Array* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Array* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Array* New() const final {
    return new Array();
  }

  Array* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Array>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Array& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Array& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Array* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Array";
  }
  protected:
  explicit Array(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kShapeFieldNumber = 2,
    kDtypeFieldNumber = 1,
    kStypeFieldNumber = 3,
    kDataFieldNumber = 4,
  };
  // repeated int32 shape = 2;
  int shape_size() const;
  private:
  int _internal_shape_size() const;
  public:
  void clear_shape();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_shape(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_shape() const;
  void _internal_add_shape(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_shape();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 shape(int index) const;
  void set_shape(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_shape(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      shape() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_shape();

  // string dtype = 1;
  void clear_dtype();
  const std::string& dtype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dtype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dtype();
  PROTOBUF_MUST_USE_RESULT std::string* release_dtype();
  void set_allocated_dtype(std::string* dtype);
  private:
  const std::string& _internal_dtype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dtype(const std::string& value);
  std::string* _internal_mutable_dtype();
  public:

  // string stype = 3;
  void clear_stype();
  const std::string& stype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stype();
  PROTOBUF_MUST_USE_RESULT std::string* release_stype();
  void set_allocated_stype(std::string* stype);
  private:
  const std::string& _internal_stype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stype(const std::string& value);
  std::string* _internal_mutable_stype();
  public:

  // bytes data = 4;
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_MUST_USE_RESULT std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:flwr.proto.Array)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > shape_;
  mutable std::atomic<int> _shape_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dtype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class MetricsRecordValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.MetricsRecordValue) */ {
 public:
  inline MetricsRecordValue() : MetricsRecordValue(nullptr) {}
  ~MetricsRecordValue() override;
  explicit constexpr MetricsRecordValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricsRecordValue(const MetricsRecordValue& from);
  MetricsRecordValue(MetricsRecordValue&& from) noexcept
    : MetricsRecordValue() {
    *this = ::std::move(from);
  }

  inline MetricsRecordValue& operator=(const MetricsRecordValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricsRecordValue& operator=(MetricsRecordValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricsRecordValue& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kDouble = 1,
    kSint64 = 2,
    kDoubleList = 21,
    kSint64List = 22,
    VALUE_NOT_SET = 0,
  };

  static inline const MetricsRecordValue* internal_default_instance() {
    return reinterpret_cast<const MetricsRecordValue*>(
               &_MetricsRecordValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(MetricsRecordValue& a, MetricsRecordValue& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricsRecordValue* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricsRecordValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MetricsRecordValue* New() const final {
    return new MetricsRecordValue();
  }

  MetricsRecordValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricsRecordValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricsRecordValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MetricsRecordValue& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricsRecordValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.MetricsRecordValue";
  }
  protected:
  explicit MetricsRecordValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDoubleFieldNumber = 1,
    kSint64FieldNumber = 2,
    kDoubleListFieldNumber = 21,
    kSint64ListFieldNumber = 22,
  };
  // double double = 1;
  bool has_double_() const;
  private:
  bool _internal_has_double_() const;
  public:
  void clear_double_();
  double double_() const;
  void set_double_(double value);
  private:
  double _internal_double_() const;
  void _internal_set_double_(double value);
  public:

  // sint64 sint64 = 2;
  bool has_sint64() const;
  private:
  bool _internal_has_sint64() const;
  public:
  void clear_sint64();
  ::PROTOBUF_NAMESPACE_ID::int64 sint64() const;
  void set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_sint64() const;
  void _internal_set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // .flwr.proto.DoubleList double_list = 21;
  bool has_double_list() const;
  private:
  bool _internal_has_double_list() const;
  public:
  void clear_double_list();
  const ::flwr::proto::DoubleList& double_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::DoubleList* release_double_list();
  ::flwr::proto::DoubleList* mutable_double_list();
  void set_allocated_double_list(::flwr::proto::DoubleList* double_list);
  private:
  const ::flwr::proto::DoubleList& _internal_double_list() const;
  ::flwr::proto::DoubleList* _internal_mutable_double_list();
  public:
  void unsafe_arena_set_allocated_double_list(
      ::flwr::proto::DoubleList* double_list);
  ::flwr::proto::DoubleList* unsafe_arena_release_double_list();

  // .flwr.proto.Sint64List sint64_list = 22;
  bool has_sint64_list() const;
  private:
  bool _internal_has_sint64_list() const;
  public:
  void clear_sint64_list();
  const ::flwr::proto::Sint64List& sint64_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Sint64List* release_sint64_list();
  ::flwr::proto::Sint64List* mutable_sint64_list();
  void set_allocated_sint64_list(::flwr::proto::Sint64List* sint64_list);
  private:
  const ::flwr::proto::Sint64List& _internal_sint64_list() const;
  ::flwr::proto::Sint64List* _internal_mutable_sint64_list();
  public:
  void unsafe_arena_set_allocated_sint64_list(
      ::flwr::proto::Sint64List* sint64_list);
  ::flwr::proto::Sint64List* unsafe_arena_release_sint64_list();

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:flwr.proto.MetricsRecordValue)
 private:
  class _Internal;
  void set_has_double_();
  void set_has_sint64();
  void set_has_double_list();
  void set_has_sint64_list();

  inline bool has_value() const;
  inline void clear_has_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union ValueUnion {
    constexpr ValueUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    double double__;
    ::PROTOBUF_NAMESPACE_ID::int64 sint64_;
    ::flwr::proto::DoubleList* double_list_;
    ::flwr::proto::Sint64List* sint64_list_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class ConfigsRecordValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.ConfigsRecordValue) */ {
 public:
  inline ConfigsRecordValue() : ConfigsRecordValue(nullptr) {}
  ~ConfigsRecordValue() override;
  explicit constexpr ConfigsRecordValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConfigsRecordValue(const ConfigsRecordValue& from);
  ConfigsRecordValue(ConfigsRecordValue&& from) noexcept
    : ConfigsRecordValue() {
    *this = ::std::move(from);
  }

  inline ConfigsRecordValue& operator=(const ConfigsRecordValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConfigsRecordValue& operator=(ConfigsRecordValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConfigsRecordValue& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kDouble = 1,
    kSint64 = 2,
    kBool = 3,
    kString = 4,
    kBytes = 5,
    kDoubleList = 21,
    kSint64List = 22,
    kBoolList = 23,
    kStringList = 24,
    kBytesList = 25,
    VALUE_NOT_SET = 0,
  };

  static inline const ConfigsRecordValue* internal_default_instance() {
    return reinterpret_cast<const ConfigsRecordValue*>(
               &_ConfigsRecordValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ConfigsRecordValue& a, ConfigsRecordValue& b) {
    a.Swap(&b);
  }
  inline void Swap(ConfigsRecordValue* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConfigsRecordValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ConfigsRecordValue* New() const final {
    return new ConfigsRecordValue();
  }

  ConfigsRecordValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConfigsRecordValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConfigsRecordValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ConfigsRecordValue& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConfigsRecordValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ConfigsRecordValue";
  }
  protected:
  explicit ConfigsRecordValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDoubleFieldNumber = 1,
    kSint64FieldNumber = 2,
    kBoolFieldNumber = 3,
    kStringFieldNumber = 4,
    kBytesFieldNumber = 5,
    kDoubleListFieldNumber = 21,
    kSint64ListFieldNumber = 22,
    kBoolListFieldNumber = 23,
    kStringListFieldNumber = 24,
    kBytesListFieldNumber = 25,
  };
  // double double = 1;
  bool has_double_() const;
  private:
  bool _internal_has_double_() const;
  public:
  void clear_double_();
  double double_() const;
  void set_double_(double value);
  private:
  double _internal_double_() const;
  void _internal_set_double_(double value);
  public:

  // sint64 sint64 = 2;
  bool has_sint64() const;
  private:
  bool _internal_has_sint64() const;
  public:
  void clear_sint64();
  ::PROTOBUF_NAMESPACE_ID::int64 sint64() const;
  void set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_sint64() const;
  void _internal_set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // bool bool = 3;
  bool has_bool_() const;
  private:
  bool _internal_has_bool_() const;
  public:
  void clear_bool_();
  bool bool_() const;
  void set_bool_(bool value);
  private:
  bool _internal_bool_() const;
  void _internal_set_bool_(bool value);
  public:

  // string string = 4;
  bool has_string() const;
  private:
  bool _internal_has_string() const;
  public:
  void clear_string();
  const std::string& string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string();
  PROTOBUF_MUST_USE_RESULT std::string* release_string();
  void set_allocated_string(std::string* string);
  private:
  const std::string& _internal_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string(const std::string& value);
  std::string* _internal_mutable_string();
  public:

  // bytes bytes = 5;
  bool has_bytes() const;
  private:
  bool _internal_has_bytes() const;
  public:
  void clear_bytes();
  const std::string& bytes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bytes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bytes();
  PROTOBUF_MUST_USE_RESULT std::string* release_bytes();
  void set_allocated_bytes(std::string* bytes);
  private:
  const std::string& _internal_bytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytes(const std::string& value);
  std::string* _internal_mutable_bytes();
  public:

  // .flwr.proto.DoubleList double_list = 21;
  bool has_double_list() const;
  private:
  bool _internal_has_double_list() const;
  public:
  void clear_double_list();
  const ::flwr::proto::DoubleList& double_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::DoubleList* release_double_list();
  ::flwr::proto::DoubleList* mutable_double_list();
  void set_allocated_double_list(::flwr::proto::DoubleList* double_list);
  private:
  const ::flwr::proto::DoubleList& _internal_double_list() const;
  ::flwr::proto::DoubleList* _internal_mutable_double_list();
  public:
  void unsafe_arena_set_allocated_double_list(
      ::flwr::proto::DoubleList* double_list);
  ::flwr::proto::DoubleList* unsafe_arena_release_double_list();

  // .flwr.proto.Sint64List sint64_list = 22;
  bool has_sint64_list() const;
  private:
  bool _internal_has_sint64_list() const;
  public:
  void clear_sint64_list();
  const ::flwr::proto::Sint64List& sint64_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Sint64List* release_sint64_list();
  ::flwr::proto::Sint64List* mutable_sint64_list();
  void set_allocated_sint64_list(::flwr::proto::Sint64List* sint64_list);
  private:
  const ::flwr::proto::Sint64List& _internal_sint64_list() const;
  ::flwr::proto::Sint64List* _internal_mutable_sint64_list();
  public:
  void unsafe_arena_set_allocated_sint64_list(
      ::flwr::proto::Sint64List* sint64_list);
  ::flwr::proto::Sint64List* unsafe_arena_release_sint64_list();

  // .flwr.proto.BoolList bool_list = 23;
  bool has_bool_list() const;
  private:
  bool _internal_has_bool_list() const;
  public:
  void clear_bool_list();
  const ::flwr::proto::BoolList& bool_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::BoolList* release_bool_list();
  ::flwr::proto::BoolList* mutable_bool_list();
  void set_allocated_bool_list(::flwr::proto::BoolList* bool_list);
  private:
  const ::flwr::proto::BoolList& _internal_bool_list() const;
  ::flwr::proto::BoolList* _internal_mutable_bool_list();
  public:
  void unsafe_arena_set_allocated_bool_list(
      ::flwr::proto::BoolList* bool_list);
  ::flwr::proto::BoolList* unsafe_arena_release_bool_list();

  // .flwr.proto.StringList string_list = 24;
  bool has_string_list() const;
  private:
  bool _internal_has_string_list() const;
  public:
  void clear_string_list();
  const ::flwr::proto::StringList& string_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::StringList* release_string_list();
  ::flwr::proto::StringList* mutable_string_list();
  void set_allocated_string_list(::flwr::proto::StringList* string_list);
  private:
  const ::flwr::proto::StringList& _internal_string_list() const;
  ::flwr::proto::StringList* _internal_mutable_string_list();
  public:
  void unsafe_arena_set_allocated_string_list(
      ::flwr::proto::StringList* string_list);
  ::flwr::proto::StringList* unsafe_arena_release_string_list();

  // .flwr.proto.BytesList bytes_list = 25;
  bool has_bytes_list() const;
  private:
  bool _internal_has_bytes_list() const;
  public:
  void clear_bytes_list();
  const ::flwr::proto::BytesList& bytes_list() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::BytesList* release_bytes_list();
  ::flwr::proto::BytesList* mutable_bytes_list();
  void set_allocated_bytes_list(::flwr::proto::BytesList* bytes_list);
  private:
  const ::flwr::proto::BytesList& _internal_bytes_list() const;
  ::flwr::proto::BytesList* _internal_mutable_bytes_list();
  public:
  void unsafe_arena_set_allocated_bytes_list(
      ::flwr::proto::BytesList* bytes_list);
  ::flwr::proto::BytesList* unsafe_arena_release_bytes_list();

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:flwr.proto.ConfigsRecordValue)
 private:
  class _Internal;
  void set_has_double_();
  void set_has_sint64();
  void set_has_bool_();
  void set_has_string();
  void set_has_bytes();
  void set_has_double_list();
  void set_has_sint64_list();
  void set_has_bool_list();
  void set_has_string_list();
  void set_has_bytes_list();

  inline bool has_value() const;
  inline void clear_has_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union ValueUnion {
    constexpr ValueUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    double double__;
    ::PROTOBUF_NAMESPACE_ID::int64 sint64_;
    bool bool__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytes_;
    ::flwr::proto::DoubleList* double_list_;
    ::flwr::proto::Sint64List* sint64_list_;
    ::flwr::proto::BoolList* bool_list_;
    ::flwr::proto::StringList* string_list_;
    ::flwr::proto::BytesList* bytes_list_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class ParametersRecord final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.ParametersRecord) */ {
 public:
  inline ParametersRecord() : ParametersRecord(nullptr) {}
  ~ParametersRecord() override;
  explicit constexpr ParametersRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ParametersRecord(const ParametersRecord& from);
  ParametersRecord(ParametersRecord&& from) noexcept
    : ParametersRecord() {
    *this = ::std::move(from);
  }

  inline ParametersRecord& operator=(const ParametersRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline ParametersRecord& operator=(ParametersRecord&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ParametersRecord& default_instance() {
    return *internal_default_instance();
  }
  static inline const ParametersRecord* internal_default_instance() {
    return reinterpret_cast<const ParametersRecord*>(
               &_ParametersRecord_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(ParametersRecord& a, ParametersRecord& b) {
    a.Swap(&b);
  }
  inline void Swap(ParametersRecord* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ParametersRecord* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ParametersRecord* New() const final {
    return new ParametersRecord();
  }

  ParametersRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ParametersRecord>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ParametersRecord& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ParametersRecord& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ParametersRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ParametersRecord";
  }
  protected:
  explicit ParametersRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataKeysFieldNumber = 1,
    kDataValuesFieldNumber = 2,
  };
  // repeated string data_keys = 1;
  int data_keys_size() const;
  private:
  int _internal_data_keys_size() const;
  public:
  void clear_data_keys();
  const std::string& data_keys(int index) const;
  std::string* mutable_data_keys(int index);
  void set_data_keys(int index, const std::string& value);
  void set_data_keys(int index, std::string&& value);
  void set_data_keys(int index, const char* value);
  void set_data_keys(int index, const char* value, size_t size);
  std::string* add_data_keys();
  void add_data_keys(const std::string& value);
  void add_data_keys(std::string&& value);
  void add_data_keys(const char* value);
  void add_data_keys(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& data_keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_data_keys();
  private:
  const std::string& _internal_data_keys(int index) const;
  std::string* _internal_add_data_keys();
  public:

  // repeated .flwr.proto.Array data_values = 2;
  int data_values_size() const;
  private:
  int _internal_data_values_size() const;
  public:
  void clear_data_values();
  ::flwr::proto::Array* mutable_data_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::Array >*
      mutable_data_values();
  private:
  const ::flwr::proto::Array& _internal_data_values(int index) const;
  ::flwr::proto::Array* _internal_add_data_values();
  public:
  const ::flwr::proto::Array& data_values(int index) const;
  ::flwr::proto::Array* add_data_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::Array >&
      data_values() const;

  // @@protoc_insertion_point(class_scope:flwr.proto.ParametersRecord)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> data_keys_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::Array > data_values_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class MetricsRecord_DataEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MetricsRecord_DataEntry_DoNotUse, 
    std::string, ::flwr::proto::MetricsRecordValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<MetricsRecord_DataEntry_DoNotUse, 
    std::string, ::flwr::proto::MetricsRecordValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  MetricsRecord_DataEntry_DoNotUse();
  explicit constexpr MetricsRecord_DataEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MetricsRecord_DataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MetricsRecord_DataEntry_DoNotUse& other);
  static const MetricsRecord_DataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MetricsRecord_DataEntry_DoNotUse*>(&_MetricsRecord_DataEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "flwr.proto.MetricsRecord.DataEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

// -------------------------------------------------------------------

class MetricsRecord final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.MetricsRecord) */ {
 public:
  inline MetricsRecord() : MetricsRecord(nullptr) {}
  ~MetricsRecord() override;
  explicit constexpr MetricsRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricsRecord(const MetricsRecord& from);
  MetricsRecord(MetricsRecord&& from) noexcept
    : MetricsRecord() {
    *this = ::std::move(from);
  }

  inline MetricsRecord& operator=(const MetricsRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline MetricsRecord& operator=(MetricsRecord&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MetricsRecord& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricsRecord* internal_default_instance() {
    return reinterpret_cast<const MetricsRecord*>(
               &_MetricsRecord_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(MetricsRecord& a, MetricsRecord& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricsRecord* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricsRecord* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline MetricsRecord* New() const final {
    return new MetricsRecord();
  }

  MetricsRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricsRecord>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MetricsRecord& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const MetricsRecord& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MetricsRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.MetricsRecord";
  }
  protected:
  explicit MetricsRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // map<string, .flwr.proto.MetricsRecordValue> data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >&
      _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >*
      _internal_mutable_data();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:flwr.proto.MetricsRecord)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      MetricsRecord_DataEntry_DoNotUse,
      std::string, ::flwr::proto::MetricsRecordValue,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class ConfigsRecord_DataEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ConfigsRecord_DataEntry_DoNotUse, 
    std::string, ::flwr::proto::ConfigsRecordValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ConfigsRecord_DataEntry_DoNotUse, 
    std::string, ::flwr::proto::ConfigsRecordValue,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ConfigsRecord_DataEntry_DoNotUse();
  explicit constexpr ConfigsRecord_DataEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ConfigsRecord_DataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ConfigsRecord_DataEntry_DoNotUse& other);
  static const ConfigsRecord_DataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ConfigsRecord_DataEntry_DoNotUse*>(&_ConfigsRecord_DataEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "flwr.proto.ConfigsRecord.DataEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

// -------------------------------------------------------------------

class ConfigsRecord final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.ConfigsRecord) */ {
 public:
  inline ConfigsRecord() : ConfigsRecord(nullptr) {}
  ~ConfigsRecord() override;
  explicit constexpr ConfigsRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConfigsRecord(const ConfigsRecord& from);
  ConfigsRecord(ConfigsRecord&& from) noexcept
    : ConfigsRecord() {
    *this = ::std::move(from);
  }

  inline ConfigsRecord& operator=(const ConfigsRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConfigsRecord& operator=(ConfigsRecord&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConfigsRecord& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConfigsRecord* internal_default_instance() {
    return reinterpret_cast<const ConfigsRecord*>(
               &_ConfigsRecord_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(ConfigsRecord& a, ConfigsRecord& b) {
    a.Swap(&b);
  }
  inline void Swap(ConfigsRecord* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConfigsRecord* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ConfigsRecord* New() const final {
    return new ConfigsRecord();
  }

  ConfigsRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConfigsRecord>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConfigsRecord& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ConfigsRecord& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConfigsRecord* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ConfigsRecord";
  }
  protected:
  explicit ConfigsRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // map<string, .flwr.proto.ConfigsRecordValue> data = 1;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >&
      _internal_data() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >*
      _internal_mutable_data();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:flwr.proto.ConfigsRecord)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ConfigsRecord_DataEntry_DoNotUse,
      std::string, ::flwr::proto::ConfigsRecordValue,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> data_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// -------------------------------------------------------------------

class RecordSet_ParametersEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_ParametersEntry_DoNotUse, 
    std::string, ::flwr::proto::ParametersRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_ParametersEntry_DoNotUse, 
    std::string, ::flwr::proto::ParametersRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  RecordSet_ParametersEntry_DoNotUse();
  explicit constexpr RecordSet_ParametersEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit RecordSet_ParametersEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const RecordSet_ParametersEntry_DoNotUse& other);
  static const RecordSet_ParametersEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const RecordSet_ParametersEntry_DoNotUse*>(&_RecordSet_ParametersEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "flwr.proto.RecordSet.ParametersEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

// -------------------------------------------------------------------

class RecordSet_MetricsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::MetricsRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::MetricsRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  RecordSet_MetricsEntry_DoNotUse();
  explicit constexpr RecordSet_MetricsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit RecordSet_MetricsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const RecordSet_MetricsEntry_DoNotUse& other);
  static const RecordSet_MetricsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const RecordSet_MetricsEntry_DoNotUse*>(&_RecordSet_MetricsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "flwr.proto.RecordSet.MetricsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

// -------------------------------------------------------------------

class RecordSet_ConfigsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_ConfigsEntry_DoNotUse, 
    std::string, ::flwr::proto::ConfigsRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RecordSet_ConfigsEntry_DoNotUse, 
    std::string, ::flwr::proto::ConfigsRecord,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  RecordSet_ConfigsEntry_DoNotUse();
  explicit constexpr RecordSet_ConfigsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit RecordSet_ConfigsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const RecordSet_ConfigsEntry_DoNotUse& other);
  static const RecordSet_ConfigsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const RecordSet_ConfigsEntry_DoNotUse*>(&_RecordSet_ConfigsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "flwr.proto.RecordSet.ConfigsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

// -------------------------------------------------------------------

class RecordSet final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:flwr.proto.RecordSet) */ {
 public:
  inline RecordSet() : RecordSet(nullptr) {}
  ~RecordSet() override;
  explicit constexpr RecordSet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RecordSet(const RecordSet& from);
  RecordSet(RecordSet&& from) noexcept
    : RecordSet() {
    *this = ::std::move(from);
  }

  inline RecordSet& operator=(const RecordSet& from) {
    CopyFrom(from);
    return *this;
  }
  inline RecordSet& operator=(RecordSet&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RecordSet& default_instance() {
    return *internal_default_instance();
  }
  static inline const RecordSet* internal_default_instance() {
    return reinterpret_cast<const RecordSet*>(
               &_RecordSet_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(RecordSet& a, RecordSet& b) {
    a.Swap(&b);
  }
  inline void Swap(RecordSet* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RecordSet* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RecordSet* New() const final {
    return new RecordSet();
  }

  RecordSet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RecordSet>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RecordSet& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RecordSet& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RecordSet* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.RecordSet";
  }
  protected:
  explicit RecordSet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kParametersFieldNumber = 1,
    kMetricsFieldNumber = 2,
    kConfigsFieldNumber = 3,
  };
  // map<string, .flwr.proto.ParametersRecord> parameters = 1;
  int parameters_size() const;
  private:
  int _internal_parameters_size() const;
  public:
  void clear_parameters();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >&
      _internal_parameters() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >*
      _internal_mutable_parameters();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >&
      parameters() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >*
      mutable_parameters();

  // map<string, .flwr.proto.MetricsRecord> metrics = 2;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >&
      _internal_metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >*
      _internal_mutable_metrics();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >&
      metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >*
      mutable_metrics();

  // map<string, .flwr.proto.ConfigsRecord> configs = 3;
  int configs_size() const;
  private:
  int _internal_configs_size() const;
  public:
  void clear_configs();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >&
      _internal_configs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >*
      _internal_mutable_configs();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >&
      configs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >*
      mutable_configs();

  // @@protoc_insertion_point(class_scope:flwr.proto.RecordSet)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      RecordSet_ParametersEntry_DoNotUse,
      std::string, ::flwr::proto::ParametersRecord,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> parameters_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      RecordSet_MetricsEntry_DoNotUse,
      std::string, ::flwr::proto::MetricsRecord,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> metrics_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      RecordSet_ConfigsEntry_DoNotUse,
      std::string, ::flwr::proto::ConfigsRecord,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> configs_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2frecordset_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// DoubleList

// repeated double vals = 1;
inline int DoubleList::_internal_vals_size() const {
  return vals_.size();
}
inline int DoubleList::vals_size() const {
  return _internal_vals_size();
}
inline void DoubleList::clear_vals() {
  vals_.Clear();
}
inline double DoubleList::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline double DoubleList::vals(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.DoubleList.vals)
  return _internal_vals(index);
}
inline void DoubleList::set_vals(int index, double value) {
  vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:flwr.proto.DoubleList.vals)
}
inline void DoubleList::_internal_add_vals(double value) {
  vals_.Add(value);
}
inline void DoubleList::add_vals(double value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:flwr.proto.DoubleList.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleList::_internal_vals() const {
  return vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
DoubleList::vals() const {
  // @@protoc_insertion_point(field_list:flwr.proto.DoubleList.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleList::_internal_mutable_vals() {
  return &vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
DoubleList::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.DoubleList.vals)
  return _internal_mutable_vals();
}

// -------------------------------------------------------------------

// Sint64List

// repeated sint64 vals = 1;
inline int Sint64List::_internal_vals_size() const {
  return vals_.size();
}
inline int Sint64List::vals_size() const {
  return _internal_vals_size();
}
inline void Sint64List::clear_vals() {
  vals_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Sint64List::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Sint64List::vals(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.Sint64List.vals)
  return _internal_vals(index);
}
inline void Sint64List::set_vals(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:flwr.proto.Sint64List.vals)
}
inline void Sint64List::_internal_add_vals(::PROTOBUF_NAMESPACE_ID::int64 value) {
  vals_.Add(value);
}
inline void Sint64List::add_vals(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:flwr.proto.Sint64List.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Sint64List::_internal_vals() const {
  return vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Sint64List::vals() const {
  // @@protoc_insertion_point(field_list:flwr.proto.Sint64List.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Sint64List::_internal_mutable_vals() {
  return &vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Sint64List::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.Sint64List.vals)
  return _internal_mutable_vals();
}

// -------------------------------------------------------------------

// BoolList

// repeated bool vals = 1;
inline int BoolList::_internal_vals_size() const {
  return vals_.size();
}
inline int BoolList::vals_size() const {
  return _internal_vals_size();
}
inline void BoolList::clear_vals() {
  vals_.Clear();
}
inline bool BoolList::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline bool BoolList::vals(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.BoolList.vals)
  return _internal_vals(index);
}
inline void BoolList::set_vals(int index, bool value) {
  vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:flwr.proto.BoolList.vals)
}
inline void BoolList::_internal_add_vals(bool value) {
  vals_.Add(value);
}
inline void BoolList::add_vals(bool value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:flwr.proto.BoolList.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolList::_internal_vals() const {
  return vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
BoolList::vals() const {
  // @@protoc_insertion_point(field_list:flwr.proto.BoolList.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolList::_internal_mutable_vals() {
  return &vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
BoolList::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.BoolList.vals)
  return _internal_mutable_vals();
}

// -------------------------------------------------------------------

// StringList

// repeated string vals = 1;
inline int StringList::_internal_vals_size() const {
  return vals_.size();
}
inline int StringList::vals_size() const {
  return _internal_vals_size();
}
inline void StringList::clear_vals() {
  vals_.Clear();
}
inline std::string* StringList::add_vals() {
  std::string* _s = _internal_add_vals();
  // @@protoc_insertion_point(field_add_mutable:flwr.proto.StringList.vals)
  return _s;
}
inline const std::string& StringList::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline const std::string& StringList::vals(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.StringList.vals)
  return _internal_vals(index);
}
inline std::string* StringList::mutable_vals(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.StringList.vals)
  return vals_.Mutable(index);
}
inline void StringList::set_vals(int index, const std::string& value) {
  vals_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:flwr.proto.StringList.vals)
}
inline void StringList::set_vals(int index, std::string&& value) {
  vals_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:flwr.proto.StringList.vals)
}
inline void StringList::set_vals(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  vals_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:flwr.proto.StringList.vals)
}
inline void StringList::set_vals(int index, const char* value, size_t size) {
  vals_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:flwr.proto.StringList.vals)
}
inline std::string* StringList::_internal_add_vals() {
  return vals_.Add();
}
inline void StringList::add_vals(const std::string& value) {
  vals_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:flwr.proto.StringList.vals)
}
inline void StringList::add_vals(std::string&& value) {
  vals_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:flwr.proto.StringList.vals)
}
inline void StringList::add_vals(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  vals_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:flwr.proto.StringList.vals)
}
inline void StringList::add_vals(const char* value, size_t size) {
  vals_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:flwr.proto.StringList.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
StringList::vals() const {
  // @@protoc_insertion_point(field_list:flwr.proto.StringList.vals)
  return vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
StringList::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.StringList.vals)
  return &vals_;
}

// -------------------------------------------------------------------

// BytesList

// repeated bytes vals = 1;
inline int BytesList::_internal_vals_size() const {
  return vals_.size();
}
inline int BytesList::vals_size() const {
  return _internal_vals_size();
}
inline void BytesList::clear_vals() {
  vals_.Clear();
}
inline std::string* BytesList::add_vals() {
  std::string* _s = _internal_add_vals();
  // @@protoc_insertion_point(field_add_mutable:flwr.proto.BytesList.vals)
  return _s;
}
inline const std::string& BytesList::_internal_vals(int index) const {
  return vals_.Get(index);
}
inline const std::string& BytesList::vals(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.BytesList.vals)
  return _internal_vals(index);
}
inline std::string* BytesList::mutable_vals(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.BytesList.vals)
  return vals_.Mutable(index);
}
inline void BytesList::set_vals(int index, const std::string& value) {
  vals_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:flwr.proto.BytesList.vals)
}
inline void BytesList::set_vals(int index, std::string&& value) {
  vals_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:flwr.proto.BytesList.vals)
}
inline void BytesList::set_vals(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  vals_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:flwr.proto.BytesList.vals)
}
inline void BytesList::set_vals(int index, const void* value, size_t size) {
  vals_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:flwr.proto.BytesList.vals)
}
inline std::string* BytesList::_internal_add_vals() {
  return vals_.Add();
}
inline void BytesList::add_vals(const std::string& value) {
  vals_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:flwr.proto.BytesList.vals)
}
inline void BytesList::add_vals(std::string&& value) {
  vals_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:flwr.proto.BytesList.vals)
}
inline void BytesList::add_vals(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  vals_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:flwr.proto.BytesList.vals)
}
inline void BytesList::add_vals(const void* value, size_t size) {
  vals_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:flwr.proto.BytesList.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
BytesList::vals() const {
  // @@protoc_insertion_point(field_list:flwr.proto.BytesList.vals)
  return vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
BytesList::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.BytesList.vals)
  return &vals_;
}

// -------------------------------------------------------------------

// Array

// string dtype = 1;
inline void Array::clear_dtype() {
  dtype_.ClearToEmpty();
}
inline const std::string& Array::dtype() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Array.dtype)
  return _internal_dtype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Array::set_dtype(ArgT0&& arg0, ArgT... args) {
 
 dtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Array.dtype)
}
inline std::string* Array::mutable_dtype() {
  std::string* _s = _internal_mutable_dtype();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Array.dtype)
  return _s;
}
inline const std::string& Array::_internal_dtype() const {
  return dtype_.Get();
}
inline void Array::_internal_set_dtype(const std::string& value) {
  
  dtype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Array::_internal_mutable_dtype() {
  
  return dtype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Array::release_dtype() {
  // @@protoc_insertion_point(field_release:flwr.proto.Array.dtype)
  return dtype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Array::set_allocated_dtype(std::string* dtype) {
  if (dtype != nullptr) {
    
  } else {
    
  }
  dtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dtype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Array.dtype)
}

// repeated int32 shape = 2;
inline int Array::_internal_shape_size() const {
  return shape_.size();
}
inline int Array::shape_size() const {
  return _internal_shape_size();
}
inline void Array::clear_shape() {
  shape_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Array::_internal_shape(int index) const {
  return shape_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Array::shape(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.Array.shape)
  return _internal_shape(index);
}
inline void Array::set_shape(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  shape_.Set(index, value);
  // @@protoc_insertion_point(field_set:flwr.proto.Array.shape)
}
inline void Array::_internal_add_shape(::PROTOBUF_NAMESPACE_ID::int32 value) {
  shape_.Add(value);
}
inline void Array::add_shape(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_shape(value);
  // @@protoc_insertion_point(field_add:flwr.proto.Array.shape)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
Array::_internal_shape() const {
  return shape_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
Array::shape() const {
  // @@protoc_insertion_point(field_list:flwr.proto.Array.shape)
  return _internal_shape();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
Array::_internal_mutable_shape() {
  return &shape_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
Array::mutable_shape() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.Array.shape)
  return _internal_mutable_shape();
}

// string stype = 3;
inline void Array::clear_stype() {
  stype_.ClearToEmpty();
}
inline const std::string& Array::stype() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Array.stype)
  return _internal_stype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Array::set_stype(ArgT0&& arg0, ArgT... args) {
 
 stype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Array.stype)
}
inline std::string* Array::mutable_stype() {
  std::string* _s = _internal_mutable_stype();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Array.stype)
  return _s;
}
inline const std::string& Array::_internal_stype() const {
  return stype_.Get();
}
inline void Array::_internal_set_stype(const std::string& value) {
  
  stype_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Array::_internal_mutable_stype() {
  
  return stype_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Array::release_stype() {
  // @@protoc_insertion_point(field_release:flwr.proto.Array.stype)
  return stype_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Array::set_allocated_stype(std::string* stype) {
  if (stype != nullptr) {
    
  } else {
    
  }
  stype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stype,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Array.stype)
}

// bytes data = 4;
inline void Array::clear_data() {
  data_.ClearToEmpty();
}
inline const std::string& Array::data() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Array.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Array::set_data(ArgT0&& arg0, ArgT... args) {
 
 data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Array.data)
}
inline std::string* Array::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Array.data)
  return _s;
}
inline const std::string& Array::_internal_data() const {
  return data_.Get();
}
inline void Array::_internal_set_data(const std::string& value) {
  
  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Array::_internal_mutable_data() {
  
  return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Array::release_data() {
  // @@protoc_insertion_point(field_release:flwr.proto.Array.data)
  return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Array::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Array.data)
}

// -------------------------------------------------------------------

// MetricsRecordValue

// double double = 1;
inline bool MetricsRecordValue::_internal_has_double_() const {
  return value_case() == kDouble;
}
inline bool MetricsRecordValue::has_double_() const {
  return _internal_has_double_();
}
inline void MetricsRecordValue::set_has_double_() {
  _oneof_case_[0] = kDouble;
}
inline void MetricsRecordValue::clear_double_() {
  if (_internal_has_double_()) {
    value_.double__ = 0;
    clear_has_value();
  }
}
inline double MetricsRecordValue::_internal_double_() const {
  if (_internal_has_double_()) {
    return value_.double__;
  }
  return 0;
}
inline void MetricsRecordValue::_internal_set_double_(double value) {
  if (!_internal_has_double_()) {
    clear_value();
    set_has_double_();
  }
  value_.double__ = value;
}
inline double MetricsRecordValue::double_() const {
  // @@protoc_insertion_point(field_get:flwr.proto.MetricsRecordValue.double)
  return _internal_double_();
}
inline void MetricsRecordValue::set_double_(double value) {
  _internal_set_double_(value);
  // @@protoc_insertion_point(field_set:flwr.proto.MetricsRecordValue.double)
}

// sint64 sint64 = 2;
inline bool MetricsRecordValue::_internal_has_sint64() const {
  return value_case() == kSint64;
}
inline bool MetricsRecordValue::has_sint64() const {
  return _internal_has_sint64();
}
inline void MetricsRecordValue::set_has_sint64() {
  _oneof_case_[0] = kSint64;
}
inline void MetricsRecordValue::clear_sint64() {
  if (_internal_has_sint64()) {
    value_.sint64_ = int64_t{0};
    clear_has_value();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MetricsRecordValue::_internal_sint64() const {
  if (_internal_has_sint64()) {
    return value_.sint64_;
  }
  return int64_t{0};
}
inline void MetricsRecordValue::_internal_set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  if (!_internal_has_sint64()) {
    clear_value();
    set_has_sint64();
  }
  value_.sint64_ = value;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 MetricsRecordValue::sint64() const {
  // @@protoc_insertion_point(field_get:flwr.proto.MetricsRecordValue.sint64)
  return _internal_sint64();
}
inline void MetricsRecordValue::set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_sint64(value);
  // @@protoc_insertion_point(field_set:flwr.proto.MetricsRecordValue.sint64)
}

// .flwr.proto.DoubleList double_list = 21;
inline bool MetricsRecordValue::_internal_has_double_list() const {
  return value_case() == kDoubleList;
}
inline bool MetricsRecordValue::has_double_list() const {
  return _internal_has_double_list();
}
inline void MetricsRecordValue::set_has_double_list() {
  _oneof_case_[0] = kDoubleList;
}
inline void MetricsRecordValue::clear_double_list() {
  if (_internal_has_double_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.double_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::DoubleList* MetricsRecordValue::release_double_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.MetricsRecordValue.double_list)
  if (_internal_has_double_list()) {
    clear_has_value();
      ::flwr::proto::DoubleList* temp = value_.double_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.double_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::DoubleList& MetricsRecordValue::_internal_double_list() const {
  return _internal_has_double_list()
      ? *value_.double_list_
      : reinterpret_cast< ::flwr::proto::DoubleList&>(::flwr::proto::_DoubleList_default_instance_);
}
inline const ::flwr::proto::DoubleList& MetricsRecordValue::double_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.MetricsRecordValue.double_list)
  return _internal_double_list();
}
inline ::flwr::proto::DoubleList* MetricsRecordValue::unsafe_arena_release_double_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.MetricsRecordValue.double_list)
  if (_internal_has_double_list()) {
    clear_has_value();
    ::flwr::proto::DoubleList* temp = value_.double_list_;
    value_.double_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MetricsRecordValue::unsafe_arena_set_allocated_double_list(::flwr::proto::DoubleList* double_list) {
  clear_value();
  if (double_list) {
    set_has_double_list();
    value_.double_list_ = double_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.MetricsRecordValue.double_list)
}
inline ::flwr::proto::DoubleList* MetricsRecordValue::_internal_mutable_double_list() {
  if (!_internal_has_double_list()) {
    clear_value();
    set_has_double_list();
    value_.double_list_ = CreateMaybeMessage< ::flwr::proto::DoubleList >(GetArenaForAllocation());
  }
  return value_.double_list_;
}
inline ::flwr::proto::DoubleList* MetricsRecordValue::mutable_double_list() {
  ::flwr::proto::DoubleList* _msg = _internal_mutable_double_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.MetricsRecordValue.double_list)
  return _msg;
}

// .flwr.proto.Sint64List sint64_list = 22;
inline bool MetricsRecordValue::_internal_has_sint64_list() const {
  return value_case() == kSint64List;
}
inline bool MetricsRecordValue::has_sint64_list() const {
  return _internal_has_sint64_list();
}
inline void MetricsRecordValue::set_has_sint64_list() {
  _oneof_case_[0] = kSint64List;
}
inline void MetricsRecordValue::clear_sint64_list() {
  if (_internal_has_sint64_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.sint64_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::Sint64List* MetricsRecordValue::release_sint64_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.MetricsRecordValue.sint64_list)
  if (_internal_has_sint64_list()) {
    clear_has_value();
      ::flwr::proto::Sint64List* temp = value_.sint64_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.sint64_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::Sint64List& MetricsRecordValue::_internal_sint64_list() const {
  return _internal_has_sint64_list()
      ? *value_.sint64_list_
      : reinterpret_cast< ::flwr::proto::Sint64List&>(::flwr::proto::_Sint64List_default_instance_);
}
inline const ::flwr::proto::Sint64List& MetricsRecordValue::sint64_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.MetricsRecordValue.sint64_list)
  return _internal_sint64_list();
}
inline ::flwr::proto::Sint64List* MetricsRecordValue::unsafe_arena_release_sint64_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.MetricsRecordValue.sint64_list)
  if (_internal_has_sint64_list()) {
    clear_has_value();
    ::flwr::proto::Sint64List* temp = value_.sint64_list_;
    value_.sint64_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MetricsRecordValue::unsafe_arena_set_allocated_sint64_list(::flwr::proto::Sint64List* sint64_list) {
  clear_value();
  if (sint64_list) {
    set_has_sint64_list();
    value_.sint64_list_ = sint64_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.MetricsRecordValue.sint64_list)
}
inline ::flwr::proto::Sint64List* MetricsRecordValue::_internal_mutable_sint64_list() {
  if (!_internal_has_sint64_list()) {
    clear_value();
    set_has_sint64_list();
    value_.sint64_list_ = CreateMaybeMessage< ::flwr::proto::Sint64List >(GetArenaForAllocation());
  }
  return value_.sint64_list_;
}
inline ::flwr::proto::Sint64List* MetricsRecordValue::mutable_sint64_list() {
  ::flwr::proto::Sint64List* _msg = _internal_mutable_sint64_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.MetricsRecordValue.sint64_list)
  return _msg;
}

inline bool MetricsRecordValue::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void MetricsRecordValue::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline MetricsRecordValue::ValueCase MetricsRecordValue::value_case() const {
  return MetricsRecordValue::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ConfigsRecordValue

// double double = 1;
inline bool ConfigsRecordValue::_internal_has_double_() const {
  return value_case() == kDouble;
}
inline bool ConfigsRecordValue::has_double_() const {
  return _internal_has_double_();
}
inline void ConfigsRecordValue::set_has_double_() {
  _oneof_case_[0] = kDouble;
}
inline void ConfigsRecordValue::clear_double_() {
  if (_internal_has_double_()) {
    value_.double__ = 0;
    clear_has_value();
  }
}
inline double ConfigsRecordValue::_internal_double_() const {
  if (_internal_has_double_()) {
    return value_.double__;
  }
  return 0;
}
inline void ConfigsRecordValue::_internal_set_double_(double value) {
  if (!_internal_has_double_()) {
    clear_value();
    set_has_double_();
  }
  value_.double__ = value;
}
inline double ConfigsRecordValue::double_() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.double)
  return _internal_double_();
}
inline void ConfigsRecordValue::set_double_(double value) {
  _internal_set_double_(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ConfigsRecordValue.double)
}

// sint64 sint64 = 2;
inline bool ConfigsRecordValue::_internal_has_sint64() const {
  return value_case() == kSint64;
}
inline bool ConfigsRecordValue::has_sint64() const {
  return _internal_has_sint64();
}
inline void ConfigsRecordValue::set_has_sint64() {
  _oneof_case_[0] = kSint64;
}
inline void ConfigsRecordValue::clear_sint64() {
  if (_internal_has_sint64()) {
    value_.sint64_ = int64_t{0};
    clear_has_value();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ConfigsRecordValue::_internal_sint64() const {
  if (_internal_has_sint64()) {
    return value_.sint64_;
  }
  return int64_t{0};
}
inline void ConfigsRecordValue::_internal_set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  if (!_internal_has_sint64()) {
    clear_value();
    set_has_sint64();
  }
  value_.sint64_ = value;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ConfigsRecordValue::sint64() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.sint64)
  return _internal_sint64();
}
inline void ConfigsRecordValue::set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_sint64(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ConfigsRecordValue.sint64)
}

// bool bool = 3;
inline bool ConfigsRecordValue::_internal_has_bool_() const {
  return value_case() == kBool;
}
inline bool ConfigsRecordValue::has_bool_() const {
  return _internal_has_bool_();
}
inline void ConfigsRecordValue::set_has_bool_() {
  _oneof_case_[0] = kBool;
}
inline void ConfigsRecordValue::clear_bool_() {
  if (_internal_has_bool_()) {
    value_.bool__ = false;
    clear_has_value();
  }
}
inline bool ConfigsRecordValue::_internal_bool_() const {
  if (_internal_has_bool_()) {
    return value_.bool__;
  }
  return false;
}
inline void ConfigsRecordValue::_internal_set_bool_(bool value) {
  if (!_internal_has_bool_()) {
    clear_value();
    set_has_bool_();
  }
  value_.bool__ = value;
}
inline bool ConfigsRecordValue::bool_() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.bool)
  return _internal_bool_();
}
inline void ConfigsRecordValue::set_bool_(bool value) {
  _internal_set_bool_(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ConfigsRecordValue.bool)
}

// string string = 4;
inline bool ConfigsRecordValue::_internal_has_string() const {
  return value_case() == kString;
}
inline bool ConfigsRecordValue::has_string() const {
  return _internal_has_string();
}
inline void ConfigsRecordValue::set_has_string() {
  _oneof_case_[0] = kString;
}
inline void ConfigsRecordValue::clear_string() {
  if (_internal_has_string()) {
    value_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_value();
  }
}
inline const std::string& ConfigsRecordValue::string() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.string)
  return _internal_string();
}
template <typename ArgT0, typename... ArgT>
inline void ConfigsRecordValue::set_string(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_string()) {
    clear_value();
    set_has_string();
    value_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.ConfigsRecordValue.string)
}
inline std::string* ConfigsRecordValue::mutable_string() {
  std::string* _s = _internal_mutable_string();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.string)
  return _s;
}
inline const std::string& ConfigsRecordValue::_internal_string() const {
  if (_internal_has_string()) {
    return value_.string_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void ConfigsRecordValue::_internal_set_string(const std::string& value) {
  if (!_internal_has_string()) {
    clear_value();
    set_has_string();
    value_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ConfigsRecordValue::_internal_mutable_string() {
  if (!_internal_has_string()) {
    clear_value();
    set_has_string();
    value_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return value_.string_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ConfigsRecordValue::release_string() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.string)
  if (_internal_has_string()) {
    clear_has_value();
    return value_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::set_allocated_string(std::string* string) {
  if (has_value()) {
    clear_value();
  }
  if (string != nullptr) {
    set_has_string();
    value_.string_.UnsafeSetDefault(string);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(string);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ConfigsRecordValue.string)
}

// bytes bytes = 5;
inline bool ConfigsRecordValue::_internal_has_bytes() const {
  return value_case() == kBytes;
}
inline bool ConfigsRecordValue::has_bytes() const {
  return _internal_has_bytes();
}
inline void ConfigsRecordValue::set_has_bytes() {
  _oneof_case_[0] = kBytes;
}
inline void ConfigsRecordValue::clear_bytes() {
  if (_internal_has_bytes()) {
    value_.bytes_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
    clear_has_value();
  }
}
inline const std::string& ConfigsRecordValue::bytes() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.bytes)
  return _internal_bytes();
}
template <typename ArgT0, typename... ArgT>
inline void ConfigsRecordValue::set_bytes(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_bytes()) {
    clear_value();
    set_has_bytes();
    value_.bytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.bytes_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.ConfigsRecordValue.bytes)
}
inline std::string* ConfigsRecordValue::mutable_bytes() {
  std::string* _s = _internal_mutable_bytes();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.bytes)
  return _s;
}
inline const std::string& ConfigsRecordValue::_internal_bytes() const {
  if (_internal_has_bytes()) {
    return value_.bytes_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void ConfigsRecordValue::_internal_set_bytes(const std::string& value) {
  if (!_internal_has_bytes()) {
    clear_value();
    set_has_bytes();
    value_.bytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.bytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ConfigsRecordValue::_internal_mutable_bytes() {
  if (!_internal_has_bytes()) {
    clear_value();
    set_has_bytes();
    value_.bytes_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return value_.bytes_.Mutable(
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ConfigsRecordValue::release_bytes() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.bytes)
  if (_internal_has_bytes()) {
    clear_has_value();
    return value_.bytes_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::set_allocated_bytes(std::string* bytes) {
  if (has_value()) {
    clear_value();
  }
  if (bytes != nullptr) {
    set_has_bytes();
    value_.bytes_.UnsafeSetDefault(bytes);
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
    if (arena != nullptr) {
      arena->Own(bytes);
    }
  }
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ConfigsRecordValue.bytes)
}

// .flwr.proto.DoubleList double_list = 21;
inline bool ConfigsRecordValue::_internal_has_double_list() const {
  return value_case() == kDoubleList;
}
inline bool ConfigsRecordValue::has_double_list() const {
  return _internal_has_double_list();
}
inline void ConfigsRecordValue::set_has_double_list() {
  _oneof_case_[0] = kDoubleList;
}
inline void ConfigsRecordValue::clear_double_list() {
  if (_internal_has_double_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.double_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::DoubleList* ConfigsRecordValue::release_double_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.double_list)
  if (_internal_has_double_list()) {
    clear_has_value();
      ::flwr::proto::DoubleList* temp = value_.double_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.double_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::DoubleList& ConfigsRecordValue::_internal_double_list() const {
  return _internal_has_double_list()
      ? *value_.double_list_
      : reinterpret_cast< ::flwr::proto::DoubleList&>(::flwr::proto::_DoubleList_default_instance_);
}
inline const ::flwr::proto::DoubleList& ConfigsRecordValue::double_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.double_list)
  return _internal_double_list();
}
inline ::flwr::proto::DoubleList* ConfigsRecordValue::unsafe_arena_release_double_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ConfigsRecordValue.double_list)
  if (_internal_has_double_list()) {
    clear_has_value();
    ::flwr::proto::DoubleList* temp = value_.double_list_;
    value_.double_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::unsafe_arena_set_allocated_double_list(::flwr::proto::DoubleList* double_list) {
  clear_value();
  if (double_list) {
    set_has_double_list();
    value_.double_list_ = double_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ConfigsRecordValue.double_list)
}
inline ::flwr::proto::DoubleList* ConfigsRecordValue::_internal_mutable_double_list() {
  if (!_internal_has_double_list()) {
    clear_value();
    set_has_double_list();
    value_.double_list_ = CreateMaybeMessage< ::flwr::proto::DoubleList >(GetArenaForAllocation());
  }
  return value_.double_list_;
}
inline ::flwr::proto::DoubleList* ConfigsRecordValue::mutable_double_list() {
  ::flwr::proto::DoubleList* _msg = _internal_mutable_double_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.double_list)
  return _msg;
}

// .flwr.proto.Sint64List sint64_list = 22;
inline bool ConfigsRecordValue::_internal_has_sint64_list() const {
  return value_case() == kSint64List;
}
inline bool ConfigsRecordValue::has_sint64_list() const {
  return _internal_has_sint64_list();
}
inline void ConfigsRecordValue::set_has_sint64_list() {
  _oneof_case_[0] = kSint64List;
}
inline void ConfigsRecordValue::clear_sint64_list() {
  if (_internal_has_sint64_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.sint64_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::Sint64List* ConfigsRecordValue::release_sint64_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.sint64_list)
  if (_internal_has_sint64_list()) {
    clear_has_value();
      ::flwr::proto::Sint64List* temp = value_.sint64_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.sint64_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::Sint64List& ConfigsRecordValue::_internal_sint64_list() const {
  return _internal_has_sint64_list()
      ? *value_.sint64_list_
      : reinterpret_cast< ::flwr::proto::Sint64List&>(::flwr::proto::_Sint64List_default_instance_);
}
inline const ::flwr::proto::Sint64List& ConfigsRecordValue::sint64_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.sint64_list)
  return _internal_sint64_list();
}
inline ::flwr::proto::Sint64List* ConfigsRecordValue::unsafe_arena_release_sint64_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ConfigsRecordValue.sint64_list)
  if (_internal_has_sint64_list()) {
    clear_has_value();
    ::flwr::proto::Sint64List* temp = value_.sint64_list_;
    value_.sint64_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::unsafe_arena_set_allocated_sint64_list(::flwr::proto::Sint64List* sint64_list) {
  clear_value();
  if (sint64_list) {
    set_has_sint64_list();
    value_.sint64_list_ = sint64_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ConfigsRecordValue.sint64_list)
}
inline ::flwr::proto::Sint64List* ConfigsRecordValue::_internal_mutable_sint64_list() {
  if (!_internal_has_sint64_list()) {
    clear_value();
    set_has_sint64_list();
    value_.sint64_list_ = CreateMaybeMessage< ::flwr::proto::Sint64List >(GetArenaForAllocation());
  }
  return value_.sint64_list_;
}
inline ::flwr::proto::Sint64List* ConfigsRecordValue::mutable_sint64_list() {
  ::flwr::proto::Sint64List* _msg = _internal_mutable_sint64_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.sint64_list)
  return _msg;
}

// .flwr.proto.BoolList bool_list = 23;
inline bool ConfigsRecordValue::_internal_has_bool_list() const {
  return value_case() == kBoolList;
}
inline bool ConfigsRecordValue::has_bool_list() const {
  return _internal_has_bool_list();
}
inline void ConfigsRecordValue::set_has_bool_list() {
  _oneof_case_[0] = kBoolList;
}
inline void ConfigsRecordValue::clear_bool_list() {
  if (_internal_has_bool_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.bool_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::BoolList* ConfigsRecordValue::release_bool_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.bool_list)
  if (_internal_has_bool_list()) {
    clear_has_value();
      ::flwr::proto::BoolList* temp = value_.bool_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.bool_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::BoolList& ConfigsRecordValue::_internal_bool_list() const {
  return _internal_has_bool_list()
      ? *value_.bool_list_
      : reinterpret_cast< ::flwr::proto::BoolList&>(::flwr::proto::_BoolList_default_instance_);
}
inline const ::flwr::proto::BoolList& ConfigsRecordValue::bool_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.bool_list)
  return _internal_bool_list();
}
inline ::flwr::proto::BoolList* ConfigsRecordValue::unsafe_arena_release_bool_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ConfigsRecordValue.bool_list)
  if (_internal_has_bool_list()) {
    clear_has_value();
    ::flwr::proto::BoolList* temp = value_.bool_list_;
    value_.bool_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::unsafe_arena_set_allocated_bool_list(::flwr::proto::BoolList* bool_list) {
  clear_value();
  if (bool_list) {
    set_has_bool_list();
    value_.bool_list_ = bool_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ConfigsRecordValue.bool_list)
}
inline ::flwr::proto::BoolList* ConfigsRecordValue::_internal_mutable_bool_list() {
  if (!_internal_has_bool_list()) {
    clear_value();
    set_has_bool_list();
    value_.bool_list_ = CreateMaybeMessage< ::flwr::proto::BoolList >(GetArenaForAllocation());
  }
  return value_.bool_list_;
}
inline ::flwr::proto::BoolList* ConfigsRecordValue::mutable_bool_list() {
  ::flwr::proto::BoolList* _msg = _internal_mutable_bool_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.bool_list)
  return _msg;
}

// .flwr.proto.StringList string_list = 24;
inline bool ConfigsRecordValue::_internal_has_string_list() const {
  return value_case() == kStringList;
}
inline bool ConfigsRecordValue::has_string_list() const {
  return _internal_has_string_list();
}
inline void ConfigsRecordValue::set_has_string_list() {
  _oneof_case_[0] = kStringList;
}
inline void ConfigsRecordValue::clear_string_list() {
  if (_internal_has_string_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.string_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::StringList* ConfigsRecordValue::release_string_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.string_list)
  if (_internal_has_string_list()) {
    clear_has_value();
      ::flwr::proto::StringList* temp = value_.string_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.string_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::StringList& ConfigsRecordValue::_internal_string_list() const {
  return _internal_has_string_list()
      ? *value_.string_list_
      : reinterpret_cast< ::flwr::proto::StringList&>(::flwr::proto::_StringList_default_instance_);
}
inline const ::flwr::proto::StringList& ConfigsRecordValue::string_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.string_list)
  return _internal_string_list();
}
inline ::flwr::proto::StringList* ConfigsRecordValue::unsafe_arena_release_string_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ConfigsRecordValue.string_list)
  if (_internal_has_string_list()) {
    clear_has_value();
    ::flwr::proto::StringList* temp = value_.string_list_;
    value_.string_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::unsafe_arena_set_allocated_string_list(::flwr::proto::StringList* string_list) {
  clear_value();
  if (string_list) {
    set_has_string_list();
    value_.string_list_ = string_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ConfigsRecordValue.string_list)
}
inline ::flwr::proto::StringList* ConfigsRecordValue::_internal_mutable_string_list() {
  if (!_internal_has_string_list()) {
    clear_value();
    set_has_string_list();
    value_.string_list_ = CreateMaybeMessage< ::flwr::proto::StringList >(GetArenaForAllocation());
  }
  return value_.string_list_;
}
inline ::flwr::proto::StringList* ConfigsRecordValue::mutable_string_list() {
  ::flwr::proto::StringList* _msg = _internal_mutable_string_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.string_list)
  return _msg;
}

// .flwr.proto.BytesList bytes_list = 25;
inline bool ConfigsRecordValue::_internal_has_bytes_list() const {
  return value_case() == kBytesList;
}
inline bool ConfigsRecordValue::has_bytes_list() const {
  return _internal_has_bytes_list();
}
inline void ConfigsRecordValue::set_has_bytes_list() {
  _oneof_case_[0] = kBytesList;
}
inline void ConfigsRecordValue::clear_bytes_list() {
  if (_internal_has_bytes_list()) {
    if (GetArenaForAllocation() == nullptr) {
      delete value_.bytes_list_;
    }
    clear_has_value();
  }
}
inline ::flwr::proto::BytesList* ConfigsRecordValue::release_bytes_list() {
  // @@protoc_insertion_point(field_release:flwr.proto.ConfigsRecordValue.bytes_list)
  if (_internal_has_bytes_list()) {
    clear_has_value();
      ::flwr::proto::BytesList* temp = value_.bytes_list_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    value_.bytes_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::BytesList& ConfigsRecordValue::_internal_bytes_list() const {
  return _internal_has_bytes_list()
      ? *value_.bytes_list_
      : reinterpret_cast< ::flwr::proto::BytesList&>(::flwr::proto::_BytesList_default_instance_);
}
inline const ::flwr::proto::BytesList& ConfigsRecordValue::bytes_list() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ConfigsRecordValue.bytes_list)
  return _internal_bytes_list();
}
inline ::flwr::proto::BytesList* ConfigsRecordValue::unsafe_arena_release_bytes_list() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ConfigsRecordValue.bytes_list)
  if (_internal_has_bytes_list()) {
    clear_has_value();
    ::flwr::proto::BytesList* temp = value_.bytes_list_;
    value_.bytes_list_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConfigsRecordValue::unsafe_arena_set_allocated_bytes_list(::flwr::proto::BytesList* bytes_list) {
  clear_value();
  if (bytes_list) {
    set_has_bytes_list();
    value_.bytes_list_ = bytes_list;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ConfigsRecordValue.bytes_list)
}
inline ::flwr::proto::BytesList* ConfigsRecordValue::_internal_mutable_bytes_list() {
  if (!_internal_has_bytes_list()) {
    clear_value();
    set_has_bytes_list();
    value_.bytes_list_ = CreateMaybeMessage< ::flwr::proto::BytesList >(GetArenaForAllocation());
  }
  return value_.bytes_list_;
}
inline ::flwr::proto::BytesList* ConfigsRecordValue::mutable_bytes_list() {
  ::flwr::proto::BytesList* _msg = _internal_mutable_bytes_list();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ConfigsRecordValue.bytes_list)
  return _msg;
}

inline bool ConfigsRecordValue::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void ConfigsRecordValue::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline ConfigsRecordValue::ValueCase ConfigsRecordValue::value_case() const {
  return ConfigsRecordValue::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ParametersRecord

// repeated string data_keys = 1;
inline int ParametersRecord::_internal_data_keys_size() const {
  return data_keys_.size();
}
inline int ParametersRecord::data_keys_size() const {
  return _internal_data_keys_size();
}
inline void ParametersRecord::clear_data_keys() {
  data_keys_.Clear();
}
inline std::string* ParametersRecord::add_data_keys() {
  std::string* _s = _internal_add_data_keys();
  // @@protoc_insertion_point(field_add_mutable:flwr.proto.ParametersRecord.data_keys)
  return _s;
}
inline const std::string& ParametersRecord::_internal_data_keys(int index) const {
  return data_keys_.Get(index);
}
inline const std::string& ParametersRecord::data_keys(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.ParametersRecord.data_keys)
  return _internal_data_keys(index);
}
inline std::string* ParametersRecord::mutable_data_keys(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.ParametersRecord.data_keys)
  return data_keys_.Mutable(index);
}
inline void ParametersRecord::set_data_keys(int index, const std::string& value) {
  data_keys_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::set_data_keys(int index, std::string&& value) {
  data_keys_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::set_data_keys(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  data_keys_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::set_data_keys(int index, const char* value, size_t size) {
  data_keys_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:flwr.proto.ParametersRecord.data_keys)
}
inline std::string* ParametersRecord::_internal_add_data_keys() {
  return data_keys_.Add();
}
inline void ParametersRecord::add_data_keys(const std::string& value) {
  data_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::add_data_keys(std::string&& value) {
  data_keys_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::add_data_keys(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  data_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:flwr.proto.ParametersRecord.data_keys)
}
inline void ParametersRecord::add_data_keys(const char* value, size_t size) {
  data_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:flwr.proto.ParametersRecord.data_keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ParametersRecord::data_keys() const {
  // @@protoc_insertion_point(field_list:flwr.proto.ParametersRecord.data_keys)
  return data_keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ParametersRecord::mutable_data_keys() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.ParametersRecord.data_keys)
  return &data_keys_;
}

// repeated .flwr.proto.Array data_values = 2;
inline int ParametersRecord::_internal_data_values_size() const {
  return data_values_.size();
}
inline int ParametersRecord::data_values_size() const {
  return _internal_data_values_size();
}
inline void ParametersRecord::clear_data_values() {
  data_values_.Clear();
}
inline ::flwr::proto::Array* ParametersRecord::mutable_data_values(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.ParametersRecord.data_values)
  return data_values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::Array >*
ParametersRecord::mutable_data_values() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.ParametersRecord.data_values)
  return &data_values_;
}
inline const ::flwr::proto::Array& ParametersRecord::_internal_data_values(int index) const {
  return data_values_.Get(index);
}
inline const ::flwr::proto::Array& ParametersRecord::data_values(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.ParametersRecord.data_values)
  return _internal_data_values(index);
}
inline ::flwr::proto::Array* ParametersRecord::_internal_add_data_values() {
  return data_values_.Add();
}
inline ::flwr::proto::Array* ParametersRecord::add_data_values() {
  ::flwr::proto::Array* _add = _internal_add_data_values();
  // @@protoc_insertion_point(field_add:flwr.proto.ParametersRecord.data_values)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::Array >&
ParametersRecord::data_values() const {
  // @@protoc_insertion_point(field_list:flwr.proto.ParametersRecord.data_values)
  return data_values_;
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// MetricsRecord

// map<string, .flwr.proto.MetricsRecordValue> data = 1;
inline int MetricsRecord::_internal_data_size() const {
  return data_.size();
}
inline int MetricsRecord::data_size() const {
  return _internal_data_size();
}
inline void MetricsRecord::clear_data() {
  data_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >&
MetricsRecord::_internal_data() const {
  return data_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >&
MetricsRecord::data() const {
  // @@protoc_insertion_point(field_map:flwr.proto.MetricsRecord.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >*
MetricsRecord::_internal_mutable_data() {
  return data_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecordValue >*
MetricsRecord::mutable_data() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.MetricsRecord.data)
  return _internal_mutable_data();
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// ConfigsRecord

// map<string, .flwr.proto.ConfigsRecordValue> data = 1;
inline int ConfigsRecord::_internal_data_size() const {
  return data_.size();
}
inline int ConfigsRecord::data_size() const {
  return _internal_data_size();
}
inline void ConfigsRecord::clear_data() {
  data_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >&
ConfigsRecord::_internal_data() const {
  return data_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >&
ConfigsRecord::data() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ConfigsRecord.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >*
ConfigsRecord::_internal_mutable_data() {
  return data_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecordValue >*
ConfigsRecord::mutable_data() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ConfigsRecord.data)
  return _internal_mutable_data();
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// RecordSet

// map<string, .flwr.proto.ParametersRecord> parameters = 1;
inline int RecordSet::_internal_parameters_size() const {
  return parameters_.size();
}
inline int RecordSet::parameters_size() const {
  return _internal_parameters_size();
}
inline void RecordSet::clear_parameters() {
  parameters_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >&
RecordSet::_internal_parameters() const {
  return parameters_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >&
RecordSet::parameters() const {
  // @@protoc_insertion_point(field_map:flwr.proto.RecordSet.parameters)
  return _internal_parameters();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >*
RecordSet::_internal_mutable_parameters() {
  return parameters_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ParametersRecord >*
RecordSet::mutable_parameters() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.RecordSet.parameters)
  return _internal_mutable_parameters();
}

// map<string, .flwr.proto.MetricsRecord> metrics = 2;
inline int RecordSet::_internal_metrics_size() const {
  return metrics_.size();
}
inline int RecordSet::metrics_size() const {
  return _internal_metrics_size();
}
inline void RecordSet::clear_metrics() {
  metrics_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >&
RecordSet::_internal_metrics() const {
  return metrics_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >&
RecordSet::metrics() const {
  // @@protoc_insertion_point(field_map:flwr.proto.RecordSet.metrics)
  return _internal_metrics();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >*
RecordSet::_internal_mutable_metrics() {
  return metrics_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::MetricsRecord >*
RecordSet::mutable_metrics() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.RecordSet.metrics)
  return _internal_mutable_metrics();
}

// map<string, .flwr.proto.ConfigsRecord> configs = 3;
inline int RecordSet::_internal_configs_size() const {
  return configs_.size();
}
inline int RecordSet::configs_size() const {
  return _internal_configs_size();
}
inline void RecordSet::clear_configs() {
  configs_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >&
RecordSet::_internal_configs() const {
  return configs_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >&
RecordSet::configs() const {
  // @@protoc_insertion_point(field_map:flwr.proto.RecordSet.configs)
  return _internal_configs();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >*
RecordSet::_internal_mutable_configs() {
  return configs_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::ConfigsRecord >*
RecordSet::mutable_configs() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.RecordSet.configs)
  return _internal_mutable_configs();
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace flwr

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2frecordset_2eproto
