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

#ifndef GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2ftransport_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2ftransport_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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_flwr_2fproto_2ftransport_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_2ftransport_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[22]
    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_2ftransport_2eproto;
namespace flwr {
namespace proto {
class ClientMessage;
struct ClientMessageDefaultTypeInternal;
extern ClientMessageDefaultTypeInternal _ClientMessage_default_instance_;
class ClientMessage_DisconnectRes;
struct ClientMessage_DisconnectResDefaultTypeInternal;
extern ClientMessage_DisconnectResDefaultTypeInternal _ClientMessage_DisconnectRes_default_instance_;
class ClientMessage_EvaluateRes;
struct ClientMessage_EvaluateResDefaultTypeInternal;
extern ClientMessage_EvaluateResDefaultTypeInternal _ClientMessage_EvaluateRes_default_instance_;
class ClientMessage_EvaluateRes_MetricsEntry_DoNotUse;
struct ClientMessage_EvaluateRes_MetricsEntry_DoNotUseDefaultTypeInternal;
extern ClientMessage_EvaluateRes_MetricsEntry_DoNotUseDefaultTypeInternal _ClientMessage_EvaluateRes_MetricsEntry_DoNotUse_default_instance_;
class ClientMessage_FitRes;
struct ClientMessage_FitResDefaultTypeInternal;
extern ClientMessage_FitResDefaultTypeInternal _ClientMessage_FitRes_default_instance_;
class ClientMessage_FitRes_MetricsEntry_DoNotUse;
struct ClientMessage_FitRes_MetricsEntry_DoNotUseDefaultTypeInternal;
extern ClientMessage_FitRes_MetricsEntry_DoNotUseDefaultTypeInternal _ClientMessage_FitRes_MetricsEntry_DoNotUse_default_instance_;
class ClientMessage_GetParametersRes;
struct ClientMessage_GetParametersResDefaultTypeInternal;
extern ClientMessage_GetParametersResDefaultTypeInternal _ClientMessage_GetParametersRes_default_instance_;
class ClientMessage_GetPropertiesRes;
struct ClientMessage_GetPropertiesResDefaultTypeInternal;
extern ClientMessage_GetPropertiesResDefaultTypeInternal _ClientMessage_GetPropertiesRes_default_instance_;
class ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse;
struct ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUseDefaultTypeInternal;
extern ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUseDefaultTypeInternal _ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse_default_instance_;
class Parameters;
struct ParametersDefaultTypeInternal;
extern ParametersDefaultTypeInternal _Parameters_default_instance_;
class Scalar;
struct ScalarDefaultTypeInternal;
extern ScalarDefaultTypeInternal _Scalar_default_instance_;
class ServerMessage;
struct ServerMessageDefaultTypeInternal;
extern ServerMessageDefaultTypeInternal _ServerMessage_default_instance_;
class ServerMessage_EvaluateIns;
struct ServerMessage_EvaluateInsDefaultTypeInternal;
extern ServerMessage_EvaluateInsDefaultTypeInternal _ServerMessage_EvaluateIns_default_instance_;
class ServerMessage_EvaluateIns_ConfigEntry_DoNotUse;
struct ServerMessage_EvaluateIns_ConfigEntry_DoNotUseDefaultTypeInternal;
extern ServerMessage_EvaluateIns_ConfigEntry_DoNotUseDefaultTypeInternal _ServerMessage_EvaluateIns_ConfigEntry_DoNotUse_default_instance_;
class ServerMessage_FitIns;
struct ServerMessage_FitInsDefaultTypeInternal;
extern ServerMessage_FitInsDefaultTypeInternal _ServerMessage_FitIns_default_instance_;
class ServerMessage_FitIns_ConfigEntry_DoNotUse;
struct ServerMessage_FitIns_ConfigEntry_DoNotUseDefaultTypeInternal;
extern ServerMessage_FitIns_ConfigEntry_DoNotUseDefaultTypeInternal _ServerMessage_FitIns_ConfigEntry_DoNotUse_default_instance_;
class ServerMessage_GetParametersIns;
struct ServerMessage_GetParametersInsDefaultTypeInternal;
extern ServerMessage_GetParametersInsDefaultTypeInternal _ServerMessage_GetParametersIns_default_instance_;
class ServerMessage_GetParametersIns_ConfigEntry_DoNotUse;
struct ServerMessage_GetParametersIns_ConfigEntry_DoNotUseDefaultTypeInternal;
extern ServerMessage_GetParametersIns_ConfigEntry_DoNotUseDefaultTypeInternal _ServerMessage_GetParametersIns_ConfigEntry_DoNotUse_default_instance_;
class ServerMessage_GetPropertiesIns;
struct ServerMessage_GetPropertiesInsDefaultTypeInternal;
extern ServerMessage_GetPropertiesInsDefaultTypeInternal _ServerMessage_GetPropertiesIns_default_instance_;
class ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse;
struct ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUseDefaultTypeInternal;
extern ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUseDefaultTypeInternal _ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse_default_instance_;
class ServerMessage_ReconnectIns;
struct ServerMessage_ReconnectInsDefaultTypeInternal;
extern ServerMessage_ReconnectInsDefaultTypeInternal _ServerMessage_ReconnectIns_default_instance_;
class Status;
struct StatusDefaultTypeInternal;
extern StatusDefaultTypeInternal _Status_default_instance_;
}  // namespace proto
}  // namespace flwr
PROTOBUF_NAMESPACE_OPEN
template<> ::flwr::proto::ClientMessage* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage>(Arena*);
template<> ::flwr::proto::ClientMessage_DisconnectRes* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_DisconnectRes>(Arena*);
template<> ::flwr::proto::ClientMessage_EvaluateRes* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_EvaluateRes>(Arena*);
template<> ::flwr::proto::ClientMessage_EvaluateRes_MetricsEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_EvaluateRes_MetricsEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ClientMessage_FitRes* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_FitRes>(Arena*);
template<> ::flwr::proto::ClientMessage_FitRes_MetricsEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_FitRes_MetricsEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ClientMessage_GetParametersRes* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_GetParametersRes>(Arena*);
template<> ::flwr::proto::ClientMessage_GetPropertiesRes* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_GetPropertiesRes>(Arena*);
template<> ::flwr::proto::ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::Parameters* Arena::CreateMaybeMessage<::flwr::proto::Parameters>(Arena*);
template<> ::flwr::proto::Scalar* Arena::CreateMaybeMessage<::flwr::proto::Scalar>(Arena*);
template<> ::flwr::proto::ServerMessage* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage>(Arena*);
template<> ::flwr::proto::ServerMessage_EvaluateIns* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_EvaluateIns>(Arena*);
template<> ::flwr::proto::ServerMessage_EvaluateIns_ConfigEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_EvaluateIns_ConfigEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ServerMessage_FitIns* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_FitIns>(Arena*);
template<> ::flwr::proto::ServerMessage_FitIns_ConfigEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_FitIns_ConfigEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ServerMessage_GetParametersIns* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_GetParametersIns>(Arena*);
template<> ::flwr::proto::ServerMessage_GetParametersIns_ConfigEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_GetParametersIns_ConfigEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ServerMessage_GetPropertiesIns* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_GetPropertiesIns>(Arena*);
template<> ::flwr::proto::ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::ServerMessage_ReconnectIns* Arena::CreateMaybeMessage<::flwr::proto::ServerMessage_ReconnectIns>(Arena*);
template<> ::flwr::proto::Status* Arena::CreateMaybeMessage<::flwr::proto::Status>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace flwr {
namespace proto {

enum Code : int {
  OK = 0,
  GET_PROPERTIES_NOT_IMPLEMENTED = 1,
  GET_PARAMETERS_NOT_IMPLEMENTED = 2,
  FIT_NOT_IMPLEMENTED = 3,
  EVALUATE_NOT_IMPLEMENTED = 4,
  Code_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Code_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Code_IsValid(int value);
constexpr Code Code_MIN = OK;
constexpr Code Code_MAX = EVALUATE_NOT_IMPLEMENTED;
constexpr int Code_ARRAYSIZE = Code_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Code_descriptor();
template<typename T>
inline const std::string& Code_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Code>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Code_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Code_descriptor(), enum_t_value);
}
inline bool Code_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Code* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Code>(
    Code_descriptor(), name, value);
}
enum Reason : int {
  UNKNOWN = 0,
  RECONNECT = 1,
  POWER_DISCONNECTED = 2,
  WIFI_UNAVAILABLE = 3,
  ACK = 4,
  Reason_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Reason_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Reason_IsValid(int value);
constexpr Reason Reason_MIN = UNKNOWN;
constexpr Reason Reason_MAX = ACK;
constexpr int Reason_ARRAYSIZE = Reason_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Reason_descriptor();
template<typename T>
inline const std::string& Reason_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Reason>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Reason_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Reason_descriptor(), enum_t_value);
}
inline bool Reason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Reason* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Reason>(
    Reason_descriptor(), name, value);
}
// ===================================================================

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

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

  inline Status& operator=(const Status& from) {
    CopyFrom(from);
    return *this;
  }
  inline Status& operator=(Status&& 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 Status& default_instance() {
    return *internal_default_instance();
  }
  static inline const Status* internal_default_instance() {
    return reinterpret_cast<const Status*>(
               &_Status_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Status>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Status& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Status& 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(Status* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Status";
  }
  protected:
  explicit Status(::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 {
    kMessageFieldNumber = 2,
    kCodeFieldNumber = 1,
  };
  // string message = 2;
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_MUST_USE_RESULT std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // .flwr.proto.Code code = 1;
  void clear_code();
  ::flwr::proto::Code code() const;
  void set_code(::flwr::proto::Code value);
  private:
  ::flwr::proto::Code _internal_code() const;
  void _internal_set_code(::flwr::proto::Code value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
  int code_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Parameters& operator=(const Parameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline Parameters& operator=(Parameters&& 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 Parameters& default_instance() {
    return *internal_default_instance();
  }
  static inline const Parameters* internal_default_instance() {
    return reinterpret_cast<const Parameters*>(
               &_Parameters_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  Parameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Parameters>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Parameters& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Parameters& 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(Parameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Parameters";
  }
  protected:
  explicit Parameters(::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 {
    kTensorsFieldNumber = 1,
    kTensorTypeFieldNumber = 2,
  };
  // repeated bytes tensors = 1;
  int tensors_size() const;
  private:
  int _internal_tensors_size() const;
  public:
  void clear_tensors();
  const std::string& tensors(int index) const;
  std::string* mutable_tensors(int index);
  void set_tensors(int index, const std::string& value);
  void set_tensors(int index, std::string&& value);
  void set_tensors(int index, const char* value);
  void set_tensors(int index, const void* value, size_t size);
  std::string* add_tensors();
  void add_tensors(const std::string& value);
  void add_tensors(std::string&& value);
  void add_tensors(const char* value);
  void add_tensors(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& tensors() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_tensors();
  private:
  const std::string& _internal_tensors(int index) const;
  std::string* _internal_add_tensors();
  public:

  // string tensor_type = 2;
  void clear_tensor_type();
  const std::string& tensor_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tensor_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tensor_type();
  PROTOBUF_MUST_USE_RESULT std::string* release_tensor_type();
  void set_allocated_tensor_type(std::string* tensor_type);
  private:
  const std::string& _internal_tensor_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tensor_type(const std::string& value);
  std::string* _internal_mutable_tensor_type();
  public:

  // @@protoc_insertion_point(class_scope:flwr.proto.Parameters)
 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> tensors_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ServerMessage_ReconnectIns& operator=(const ServerMessage_ReconnectIns& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage_ReconnectIns& operator=(ServerMessage_ReconnectIns&& 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 ServerMessage_ReconnectIns& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessage_ReconnectIns* internal_default_instance() {
    return reinterpret_cast<const ServerMessage_ReconnectIns*>(
               &_ServerMessage_ReconnectIns_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  ServerMessage_ReconnectIns* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage_ReconnectIns>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage_ReconnectIns& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage_ReconnectIns& 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(ServerMessage_ReconnectIns* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage.ReconnectIns";
  }
  protected:
  explicit ServerMessage_ReconnectIns(::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 {
    kSecondsFieldNumber = 1,
  };
  // int64 seconds = 1;
  void clear_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 seconds() const;
  void set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds() const;
  void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 seconds_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

class ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse();
  explicit constexpr ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse& other);
  static const ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ServerMessage_GetPropertiesIns_ConfigEntry_DoNotUse*>(&_ServerMessage_GetPropertiesIns_ConfigEntry_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.ServerMessage.GetPropertiesIns.ConfigEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ServerMessage_GetPropertiesIns& operator=(const ServerMessage_GetPropertiesIns& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage_GetPropertiesIns& operator=(ServerMessage_GetPropertiesIns&& 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 ServerMessage_GetPropertiesIns& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessage_GetPropertiesIns* internal_default_instance() {
    return reinterpret_cast<const ServerMessage_GetPropertiesIns*>(
               &_ServerMessage_GetPropertiesIns_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  ServerMessage_GetPropertiesIns* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage_GetPropertiesIns>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage_GetPropertiesIns& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage_GetPropertiesIns& 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(ServerMessage_GetPropertiesIns* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage.GetPropertiesIns";
  }
  protected:
  explicit ServerMessage_GetPropertiesIns(::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 {
    kConfigFieldNumber = 1,
  };
  // map<string, .flwr.proto.Scalar> config = 1;
  int config_size() const;
  private:
  int _internal_config_size() const;
  public:
  void clear_config();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_config();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_config();

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

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

class ServerMessage_GetParametersIns_ConfigEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_GetParametersIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_GetParametersIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ServerMessage_GetParametersIns_ConfigEntry_DoNotUse();
  explicit constexpr ServerMessage_GetParametersIns_ConfigEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ServerMessage_GetParametersIns_ConfigEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ServerMessage_GetParametersIns_ConfigEntry_DoNotUse& other);
  static const ServerMessage_GetParametersIns_ConfigEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ServerMessage_GetParametersIns_ConfigEntry_DoNotUse*>(&_ServerMessage_GetParametersIns_ConfigEntry_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.ServerMessage.GetParametersIns.ConfigEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ServerMessage_GetParametersIns& operator=(const ServerMessage_GetParametersIns& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage_GetParametersIns& operator=(ServerMessage_GetParametersIns&& 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 ServerMessage_GetParametersIns& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessage_GetParametersIns* internal_default_instance() {
    return reinterpret_cast<const ServerMessage_GetParametersIns*>(
               &_ServerMessage_GetParametersIns_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

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

  ServerMessage_GetParametersIns* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage_GetParametersIns>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage_GetParametersIns& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage_GetParametersIns& 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(ServerMessage_GetParametersIns* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage.GetParametersIns";
  }
  protected:
  explicit ServerMessage_GetParametersIns(::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 {
    kConfigFieldNumber = 1,
  };
  // map<string, .flwr.proto.Scalar> config = 1;
  int config_size() const;
  private:
  int _internal_config_size() const;
  public:
  void clear_config();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_config();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_config();

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

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

class ServerMessage_FitIns_ConfigEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_FitIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_FitIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ServerMessage_FitIns_ConfigEntry_DoNotUse();
  explicit constexpr ServerMessage_FitIns_ConfigEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ServerMessage_FitIns_ConfigEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ServerMessage_FitIns_ConfigEntry_DoNotUse& other);
  static const ServerMessage_FitIns_ConfigEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ServerMessage_FitIns_ConfigEntry_DoNotUse*>(&_ServerMessage_FitIns_ConfigEntry_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.ServerMessage.FitIns.ConfigEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ServerMessage_FitIns& operator=(const ServerMessage_FitIns& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage_FitIns& operator=(ServerMessage_FitIns&& 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 ServerMessage_FitIns& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessage_FitIns* internal_default_instance() {
    return reinterpret_cast<const ServerMessage_FitIns*>(
               &_ServerMessage_FitIns_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

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

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

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

  ServerMessage_FitIns* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage_FitIns>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage_FitIns& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage_FitIns& 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(ServerMessage_FitIns* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage.FitIns";
  }
  protected:
  explicit ServerMessage_FitIns(::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 {
    kConfigFieldNumber = 2,
    kParametersFieldNumber = 1,
  };
  // map<string, .flwr.proto.Scalar> config = 2;
  int config_size() const;
  private:
  int _internal_config_size() const;
  public:
  void clear_config();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_config();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_config();

  // .flwr.proto.Parameters parameters = 1;
  bool has_parameters() const;
  private:
  bool _internal_has_parameters() const;
  public:
  void clear_parameters();
  const ::flwr::proto::Parameters& parameters() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Parameters* release_parameters();
  ::flwr::proto::Parameters* mutable_parameters();
  void set_allocated_parameters(::flwr::proto::Parameters* parameters);
  private:
  const ::flwr::proto::Parameters& _internal_parameters() const;
  ::flwr::proto::Parameters* _internal_mutable_parameters();
  public:
  void unsafe_arena_set_allocated_parameters(
      ::flwr::proto::Parameters* parameters);
  ::flwr::proto::Parameters* unsafe_arena_release_parameters();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ServerMessage_FitIns_ConfigEntry_DoNotUse,
      std::string, ::flwr::proto::Scalar,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> config_;
  ::flwr::proto::Parameters* parameters_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

class ServerMessage_EvaluateIns_ConfigEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_EvaluateIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ServerMessage_EvaluateIns_ConfigEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ServerMessage_EvaluateIns_ConfigEntry_DoNotUse();
  explicit constexpr ServerMessage_EvaluateIns_ConfigEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ServerMessage_EvaluateIns_ConfigEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ServerMessage_EvaluateIns_ConfigEntry_DoNotUse& other);
  static const ServerMessage_EvaluateIns_ConfigEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ServerMessage_EvaluateIns_ConfigEntry_DoNotUse*>(&_ServerMessage_EvaluateIns_ConfigEntry_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.ServerMessage.EvaluateIns.ConfigEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ServerMessage_EvaluateIns& operator=(const ServerMessage_EvaluateIns& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage_EvaluateIns& operator=(ServerMessage_EvaluateIns&& 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 ServerMessage_EvaluateIns& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerMessage_EvaluateIns* internal_default_instance() {
    return reinterpret_cast<const ServerMessage_EvaluateIns*>(
               &_ServerMessage_EvaluateIns_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

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

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

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

  ServerMessage_EvaluateIns* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage_EvaluateIns>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage_EvaluateIns& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage_EvaluateIns& 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(ServerMessage_EvaluateIns* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage.EvaluateIns";
  }
  protected:
  explicit ServerMessage_EvaluateIns(::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 {
    kConfigFieldNumber = 2,
    kParametersFieldNumber = 1,
  };
  // map<string, .flwr.proto.Scalar> config = 2;
  int config_size() const;
  private:
  int _internal_config_size() const;
  public:
  void clear_config();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_config();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      config() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_config();

  // .flwr.proto.Parameters parameters = 1;
  bool has_parameters() const;
  private:
  bool _internal_has_parameters() const;
  public:
  void clear_parameters();
  const ::flwr::proto::Parameters& parameters() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Parameters* release_parameters();
  ::flwr::proto::Parameters* mutable_parameters();
  void set_allocated_parameters(::flwr::proto::Parameters* parameters);
  private:
  const ::flwr::proto::Parameters& _internal_parameters() const;
  ::flwr::proto::Parameters* _internal_mutable_parameters();
  public:
  void unsafe_arena_set_allocated_parameters(
      ::flwr::proto::Parameters* parameters);
  ::flwr::proto::Parameters* unsafe_arena_release_parameters();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ServerMessage_EvaluateIns_ConfigEntry_DoNotUse,
      std::string, ::flwr::proto::Scalar,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> config_;
  ::flwr::proto::Parameters* parameters_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ServerMessage& operator=(const ServerMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerMessage& operator=(ServerMessage&& 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 ServerMessage& default_instance() {
    return *internal_default_instance();
  }
  enum MsgCase {
    kReconnectIns = 1,
    kGetPropertiesIns = 2,
    kGetParametersIns = 3,
    kFitIns = 4,
    kEvaluateIns = 5,
    MSG_NOT_SET = 0,
  };

  static inline const ServerMessage* internal_default_instance() {
    return reinterpret_cast<const ServerMessage*>(
               &_ServerMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

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

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

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

  ServerMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ServerMessage& 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(ServerMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ServerMessage";
  }
  protected:
  explicit ServerMessage(::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 ----------------------------------------------------

  typedef ServerMessage_ReconnectIns ReconnectIns;
  typedef ServerMessage_GetPropertiesIns GetPropertiesIns;
  typedef ServerMessage_GetParametersIns GetParametersIns;
  typedef ServerMessage_FitIns FitIns;
  typedef ServerMessage_EvaluateIns EvaluateIns;

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

  enum : int {
    kReconnectInsFieldNumber = 1,
    kGetPropertiesInsFieldNumber = 2,
    kGetParametersInsFieldNumber = 3,
    kFitInsFieldNumber = 4,
    kEvaluateInsFieldNumber = 5,
  };
  // .flwr.proto.ServerMessage.ReconnectIns reconnect_ins = 1;
  bool has_reconnect_ins() const;
  private:
  bool _internal_has_reconnect_ins() const;
  public:
  void clear_reconnect_ins();
  const ::flwr::proto::ServerMessage_ReconnectIns& reconnect_ins() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ServerMessage_ReconnectIns* release_reconnect_ins();
  ::flwr::proto::ServerMessage_ReconnectIns* mutable_reconnect_ins();
  void set_allocated_reconnect_ins(::flwr::proto::ServerMessage_ReconnectIns* reconnect_ins);
  private:
  const ::flwr::proto::ServerMessage_ReconnectIns& _internal_reconnect_ins() const;
  ::flwr::proto::ServerMessage_ReconnectIns* _internal_mutable_reconnect_ins();
  public:
  void unsafe_arena_set_allocated_reconnect_ins(
      ::flwr::proto::ServerMessage_ReconnectIns* reconnect_ins);
  ::flwr::proto::ServerMessage_ReconnectIns* unsafe_arena_release_reconnect_ins();

  // .flwr.proto.ServerMessage.GetPropertiesIns get_properties_ins = 2;
  bool has_get_properties_ins() const;
  private:
  bool _internal_has_get_properties_ins() const;
  public:
  void clear_get_properties_ins();
  const ::flwr::proto::ServerMessage_GetPropertiesIns& get_properties_ins() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ServerMessage_GetPropertiesIns* release_get_properties_ins();
  ::flwr::proto::ServerMessage_GetPropertiesIns* mutable_get_properties_ins();
  void set_allocated_get_properties_ins(::flwr::proto::ServerMessage_GetPropertiesIns* get_properties_ins);
  private:
  const ::flwr::proto::ServerMessage_GetPropertiesIns& _internal_get_properties_ins() const;
  ::flwr::proto::ServerMessage_GetPropertiesIns* _internal_mutable_get_properties_ins();
  public:
  void unsafe_arena_set_allocated_get_properties_ins(
      ::flwr::proto::ServerMessage_GetPropertiesIns* get_properties_ins);
  ::flwr::proto::ServerMessage_GetPropertiesIns* unsafe_arena_release_get_properties_ins();

  // .flwr.proto.ServerMessage.GetParametersIns get_parameters_ins = 3;
  bool has_get_parameters_ins() const;
  private:
  bool _internal_has_get_parameters_ins() const;
  public:
  void clear_get_parameters_ins();
  const ::flwr::proto::ServerMessage_GetParametersIns& get_parameters_ins() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ServerMessage_GetParametersIns* release_get_parameters_ins();
  ::flwr::proto::ServerMessage_GetParametersIns* mutable_get_parameters_ins();
  void set_allocated_get_parameters_ins(::flwr::proto::ServerMessage_GetParametersIns* get_parameters_ins);
  private:
  const ::flwr::proto::ServerMessage_GetParametersIns& _internal_get_parameters_ins() const;
  ::flwr::proto::ServerMessage_GetParametersIns* _internal_mutable_get_parameters_ins();
  public:
  void unsafe_arena_set_allocated_get_parameters_ins(
      ::flwr::proto::ServerMessage_GetParametersIns* get_parameters_ins);
  ::flwr::proto::ServerMessage_GetParametersIns* unsafe_arena_release_get_parameters_ins();

  // .flwr.proto.ServerMessage.FitIns fit_ins = 4;
  bool has_fit_ins() const;
  private:
  bool _internal_has_fit_ins() const;
  public:
  void clear_fit_ins();
  const ::flwr::proto::ServerMessage_FitIns& fit_ins() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ServerMessage_FitIns* release_fit_ins();
  ::flwr::proto::ServerMessage_FitIns* mutable_fit_ins();
  void set_allocated_fit_ins(::flwr::proto::ServerMessage_FitIns* fit_ins);
  private:
  const ::flwr::proto::ServerMessage_FitIns& _internal_fit_ins() const;
  ::flwr::proto::ServerMessage_FitIns* _internal_mutable_fit_ins();
  public:
  void unsafe_arena_set_allocated_fit_ins(
      ::flwr::proto::ServerMessage_FitIns* fit_ins);
  ::flwr::proto::ServerMessage_FitIns* unsafe_arena_release_fit_ins();

  // .flwr.proto.ServerMessage.EvaluateIns evaluate_ins = 5;
  bool has_evaluate_ins() const;
  private:
  bool _internal_has_evaluate_ins() const;
  public:
  void clear_evaluate_ins();
  const ::flwr::proto::ServerMessage_EvaluateIns& evaluate_ins() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ServerMessage_EvaluateIns* release_evaluate_ins();
  ::flwr::proto::ServerMessage_EvaluateIns* mutable_evaluate_ins();
  void set_allocated_evaluate_ins(::flwr::proto::ServerMessage_EvaluateIns* evaluate_ins);
  private:
  const ::flwr::proto::ServerMessage_EvaluateIns& _internal_evaluate_ins() const;
  ::flwr::proto::ServerMessage_EvaluateIns* _internal_mutable_evaluate_ins();
  public:
  void unsafe_arena_set_allocated_evaluate_ins(
      ::flwr::proto::ServerMessage_EvaluateIns* evaluate_ins);
  ::flwr::proto::ServerMessage_EvaluateIns* unsafe_arena_release_evaluate_ins();

  void clear_msg();
  MsgCase msg_case() const;
  // @@protoc_insertion_point(class_scope:flwr.proto.ServerMessage)
 private:
  class _Internal;
  void set_has_reconnect_ins();
  void set_has_get_properties_ins();
  void set_has_get_parameters_ins();
  void set_has_fit_ins();
  void set_has_evaluate_ins();

  inline bool has_msg() const;
  inline void clear_has_msg();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union MsgUnion {
    constexpr MsgUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::flwr::proto::ServerMessage_ReconnectIns* reconnect_ins_;
    ::flwr::proto::ServerMessage_GetPropertiesIns* get_properties_ins_;
    ::flwr::proto::ServerMessage_GetParametersIns* get_parameters_ins_;
    ::flwr::proto::ServerMessage_FitIns* fit_ins_;
    ::flwr::proto::ServerMessage_EvaluateIns* evaluate_ins_;
  } msg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ClientMessage_DisconnectRes& operator=(const ClientMessage_DisconnectRes& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage_DisconnectRes& operator=(ClientMessage_DisconnectRes&& 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 ClientMessage_DisconnectRes& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessage_DisconnectRes* internal_default_instance() {
    return reinterpret_cast<const ClientMessage_DisconnectRes*>(
               &_ClientMessage_DisconnectRes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

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

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

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

  ClientMessage_DisconnectRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage_DisconnectRes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage_DisconnectRes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage_DisconnectRes& 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(ClientMessage_DisconnectRes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage.DisconnectRes";
  }
  protected:
  explicit ClientMessage_DisconnectRes(::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 {
    kReasonFieldNumber = 1,
  };
  // .flwr.proto.Reason reason = 1;
  void clear_reason();
  ::flwr::proto::Reason reason() const;
  void set_reason(::flwr::proto::Reason value);
  private:
  ::flwr::proto::Reason _internal_reason() const;
  void _internal_set_reason(::flwr::proto::Reason value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int reason_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

class ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse();
  explicit constexpr ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse& other);
  static const ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse*>(&_ClientMessage_GetPropertiesRes_PropertiesEntry_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.ClientMessage.GetPropertiesRes.PropertiesEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ClientMessage_GetPropertiesRes& operator=(const ClientMessage_GetPropertiesRes& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage_GetPropertiesRes& operator=(ClientMessage_GetPropertiesRes&& 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 ClientMessage_GetPropertiesRes& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessage_GetPropertiesRes* internal_default_instance() {
    return reinterpret_cast<const ClientMessage_GetPropertiesRes*>(
               &_ClientMessage_GetPropertiesRes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

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

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

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

  ClientMessage_GetPropertiesRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage_GetPropertiesRes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage_GetPropertiesRes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage_GetPropertiesRes& 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(ClientMessage_GetPropertiesRes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage.GetPropertiesRes";
  }
  protected:
  explicit ClientMessage_GetPropertiesRes(::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 {
    kPropertiesFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // map<string, .flwr.proto.Scalar> properties = 2;
  int properties_size() const;
  private:
  int _internal_properties_size() const;
  public:
  void clear_properties();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_properties() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_properties();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      properties() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_properties();

  // .flwr.proto.Status status = 1;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  const ::flwr::proto::Status& status() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Status* release_status();
  ::flwr::proto::Status* mutable_status();
  void set_allocated_status(::flwr::proto::Status* status);
  private:
  const ::flwr::proto::Status& _internal_status() const;
  ::flwr::proto::Status* _internal_mutable_status();
  public:
  void unsafe_arena_set_allocated_status(
      ::flwr::proto::Status* status);
  ::flwr::proto::Status* unsafe_arena_release_status();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ClientMessage_GetPropertiesRes_PropertiesEntry_DoNotUse,
      std::string, ::flwr::proto::Scalar,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> properties_;
  ::flwr::proto::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ClientMessage_GetParametersRes& operator=(const ClientMessage_GetParametersRes& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage_GetParametersRes& operator=(ClientMessage_GetParametersRes&& 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 ClientMessage_GetParametersRes& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessage_GetParametersRes* internal_default_instance() {
    return reinterpret_cast<const ClientMessage_GetParametersRes*>(
               &_ClientMessage_GetParametersRes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

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

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

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

  ClientMessage_GetParametersRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage_GetParametersRes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage_GetParametersRes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage_GetParametersRes& 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(ClientMessage_GetParametersRes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage.GetParametersRes";
  }
  protected:
  explicit ClientMessage_GetParametersRes(::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 {
    kStatusFieldNumber = 1,
    kParametersFieldNumber = 2,
  };
  // .flwr.proto.Status status = 1;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  const ::flwr::proto::Status& status() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Status* release_status();
  ::flwr::proto::Status* mutable_status();
  void set_allocated_status(::flwr::proto::Status* status);
  private:
  const ::flwr::proto::Status& _internal_status() const;
  ::flwr::proto::Status* _internal_mutable_status();
  public:
  void unsafe_arena_set_allocated_status(
      ::flwr::proto::Status* status);
  ::flwr::proto::Status* unsafe_arena_release_status();

  // .flwr.proto.Parameters parameters = 2;
  bool has_parameters() const;
  private:
  bool _internal_has_parameters() const;
  public:
  void clear_parameters();
  const ::flwr::proto::Parameters& parameters() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Parameters* release_parameters();
  ::flwr::proto::Parameters* mutable_parameters();
  void set_allocated_parameters(::flwr::proto::Parameters* parameters);
  private:
  const ::flwr::proto::Parameters& _internal_parameters() const;
  ::flwr::proto::Parameters* _internal_mutable_parameters();
  public:
  void unsafe_arena_set_allocated_parameters(
      ::flwr::proto::Parameters* parameters);
  ::flwr::proto::Parameters* unsafe_arena_release_parameters();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::flwr::proto::Status* status_;
  ::flwr::proto::Parameters* parameters_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

class ClientMessage_FitRes_MetricsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_FitRes_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_FitRes_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ClientMessage_FitRes_MetricsEntry_DoNotUse();
  explicit constexpr ClientMessage_FitRes_MetricsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ClientMessage_FitRes_MetricsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ClientMessage_FitRes_MetricsEntry_DoNotUse& other);
  static const ClientMessage_FitRes_MetricsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ClientMessage_FitRes_MetricsEntry_DoNotUse*>(&_ClientMessage_FitRes_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.ClientMessage.FitRes.MetricsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ClientMessage_FitRes& operator=(const ClientMessage_FitRes& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage_FitRes& operator=(ClientMessage_FitRes&& 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 ClientMessage_FitRes& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessage_FitRes* internal_default_instance() {
    return reinterpret_cast<const ClientMessage_FitRes*>(
               &_ClientMessage_FitRes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

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

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

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

  ClientMessage_FitRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage_FitRes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage_FitRes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage_FitRes& 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(ClientMessage_FitRes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage.FitRes";
  }
  protected:
  explicit ClientMessage_FitRes(::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 {
    kMetricsFieldNumber = 4,
    kStatusFieldNumber = 1,
    kParametersFieldNumber = 2,
    kNumExamplesFieldNumber = 3,
  };
  // map<string, .flwr.proto.Scalar> metrics = 4;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_metrics();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_metrics();

  // .flwr.proto.Status status = 1;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  const ::flwr::proto::Status& status() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Status* release_status();
  ::flwr::proto::Status* mutable_status();
  void set_allocated_status(::flwr::proto::Status* status);
  private:
  const ::flwr::proto::Status& _internal_status() const;
  ::flwr::proto::Status* _internal_mutable_status();
  public:
  void unsafe_arena_set_allocated_status(
      ::flwr::proto::Status* status);
  ::flwr::proto::Status* unsafe_arena_release_status();

  // .flwr.proto.Parameters parameters = 2;
  bool has_parameters() const;
  private:
  bool _internal_has_parameters() const;
  public:
  void clear_parameters();
  const ::flwr::proto::Parameters& parameters() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Parameters* release_parameters();
  ::flwr::proto::Parameters* mutable_parameters();
  void set_allocated_parameters(::flwr::proto::Parameters* parameters);
  private:
  const ::flwr::proto::Parameters& _internal_parameters() const;
  ::flwr::proto::Parameters* _internal_mutable_parameters();
  public:
  void unsafe_arena_set_allocated_parameters(
      ::flwr::proto::Parameters* parameters);
  ::flwr::proto::Parameters* unsafe_arena_release_parameters();

  // int64 num_examples = 3;
  void clear_num_examples();
  ::PROTOBUF_NAMESPACE_ID::int64 num_examples() const;
  void set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_examples() const;
  void _internal_set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ClientMessage_FitRes_MetricsEntry_DoNotUse,
      std::string, ::flwr::proto::Scalar,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> metrics_;
  ::flwr::proto::Status* status_;
  ::flwr::proto::Parameters* parameters_;
  ::PROTOBUF_NAMESPACE_ID::int64 num_examples_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

class ClientMessage_EvaluateRes_MetricsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_EvaluateRes_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<ClientMessage_EvaluateRes_MetricsEntry_DoNotUse, 
    std::string, ::flwr::proto::Scalar,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ClientMessage_EvaluateRes_MetricsEntry_DoNotUse();
  explicit constexpr ClientMessage_EvaluateRes_MetricsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ClientMessage_EvaluateRes_MetricsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ClientMessage_EvaluateRes_MetricsEntry_DoNotUse& other);
  static const ClientMessage_EvaluateRes_MetricsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ClientMessage_EvaluateRes_MetricsEntry_DoNotUse*>(&_ClientMessage_EvaluateRes_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.ClientMessage.EvaluateRes.MetricsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

  inline ClientMessage_EvaluateRes& operator=(const ClientMessage_EvaluateRes& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage_EvaluateRes& operator=(ClientMessage_EvaluateRes&& 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 ClientMessage_EvaluateRes& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientMessage_EvaluateRes* internal_default_instance() {
    return reinterpret_cast<const ClientMessage_EvaluateRes*>(
               &_ClientMessage_EvaluateRes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

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

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

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

  ClientMessage_EvaluateRes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage_EvaluateRes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage_EvaluateRes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage_EvaluateRes& 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(ClientMessage_EvaluateRes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage.EvaluateRes";
  }
  protected:
  explicit ClientMessage_EvaluateRes(::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 {
    kMetricsFieldNumber = 4,
    kStatusFieldNumber = 1,
    kNumExamplesFieldNumber = 3,
    kLossFieldNumber = 2,
  };
  // map<string, .flwr.proto.Scalar> metrics = 4;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      _internal_metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      _internal_mutable_metrics();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
      metrics() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
      mutable_metrics();

  // .flwr.proto.Status status = 1;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  const ::flwr::proto::Status& status() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Status* release_status();
  ::flwr::proto::Status* mutable_status();
  void set_allocated_status(::flwr::proto::Status* status);
  private:
  const ::flwr::proto::Status& _internal_status() const;
  ::flwr::proto::Status* _internal_mutable_status();
  public:
  void unsafe_arena_set_allocated_status(
      ::flwr::proto::Status* status);
  ::flwr::proto::Status* unsafe_arena_release_status();

  // int64 num_examples = 3;
  void clear_num_examples();
  ::PROTOBUF_NAMESPACE_ID::int64 num_examples() const;
  void set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_examples() const;
  void _internal_set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // float loss = 2;
  void clear_loss();
  float loss() const;
  void set_loss(float value);
  private:
  float _internal_loss() const;
  void _internal_set_loss(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      ClientMessage_EvaluateRes_MetricsEntry_DoNotUse,
      std::string, ::flwr::proto::Scalar,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> metrics_;
  ::flwr::proto::Status* status_;
  ::PROTOBUF_NAMESPACE_ID::int64 num_examples_;
  float loss_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ClientMessage& operator=(const ClientMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientMessage& operator=(ClientMessage&& 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 ClientMessage& default_instance() {
    return *internal_default_instance();
  }
  enum MsgCase {
    kDisconnectRes = 1,
    kGetPropertiesRes = 2,
    kGetParametersRes = 3,
    kFitRes = 4,
    kEvaluateRes = 5,
    MSG_NOT_SET = 0,
  };

  static inline const ClientMessage* internal_default_instance() {
    return reinterpret_cast<const ClientMessage*>(
               &_ClientMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

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

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

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

  ClientMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientMessage& 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(ClientMessage* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.ClientMessage";
  }
  protected:
  explicit ClientMessage(::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 ----------------------------------------------------

  typedef ClientMessage_DisconnectRes DisconnectRes;
  typedef ClientMessage_GetPropertiesRes GetPropertiesRes;
  typedef ClientMessage_GetParametersRes GetParametersRes;
  typedef ClientMessage_FitRes FitRes;
  typedef ClientMessage_EvaluateRes EvaluateRes;

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

  enum : int {
    kDisconnectResFieldNumber = 1,
    kGetPropertiesResFieldNumber = 2,
    kGetParametersResFieldNumber = 3,
    kFitResFieldNumber = 4,
    kEvaluateResFieldNumber = 5,
  };
  // .flwr.proto.ClientMessage.DisconnectRes disconnect_res = 1;
  bool has_disconnect_res() const;
  private:
  bool _internal_has_disconnect_res() const;
  public:
  void clear_disconnect_res();
  const ::flwr::proto::ClientMessage_DisconnectRes& disconnect_res() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ClientMessage_DisconnectRes* release_disconnect_res();
  ::flwr::proto::ClientMessage_DisconnectRes* mutable_disconnect_res();
  void set_allocated_disconnect_res(::flwr::proto::ClientMessage_DisconnectRes* disconnect_res);
  private:
  const ::flwr::proto::ClientMessage_DisconnectRes& _internal_disconnect_res() const;
  ::flwr::proto::ClientMessage_DisconnectRes* _internal_mutable_disconnect_res();
  public:
  void unsafe_arena_set_allocated_disconnect_res(
      ::flwr::proto::ClientMessage_DisconnectRes* disconnect_res);
  ::flwr::proto::ClientMessage_DisconnectRes* unsafe_arena_release_disconnect_res();

  // .flwr.proto.ClientMessage.GetPropertiesRes get_properties_res = 2;
  bool has_get_properties_res() const;
  private:
  bool _internal_has_get_properties_res() const;
  public:
  void clear_get_properties_res();
  const ::flwr::proto::ClientMessage_GetPropertiesRes& get_properties_res() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ClientMessage_GetPropertiesRes* release_get_properties_res();
  ::flwr::proto::ClientMessage_GetPropertiesRes* mutable_get_properties_res();
  void set_allocated_get_properties_res(::flwr::proto::ClientMessage_GetPropertiesRes* get_properties_res);
  private:
  const ::flwr::proto::ClientMessage_GetPropertiesRes& _internal_get_properties_res() const;
  ::flwr::proto::ClientMessage_GetPropertiesRes* _internal_mutable_get_properties_res();
  public:
  void unsafe_arena_set_allocated_get_properties_res(
      ::flwr::proto::ClientMessage_GetPropertiesRes* get_properties_res);
  ::flwr::proto::ClientMessage_GetPropertiesRes* unsafe_arena_release_get_properties_res();

  // .flwr.proto.ClientMessage.GetParametersRes get_parameters_res = 3;
  bool has_get_parameters_res() const;
  private:
  bool _internal_has_get_parameters_res() const;
  public:
  void clear_get_parameters_res();
  const ::flwr::proto::ClientMessage_GetParametersRes& get_parameters_res() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ClientMessage_GetParametersRes* release_get_parameters_res();
  ::flwr::proto::ClientMessage_GetParametersRes* mutable_get_parameters_res();
  void set_allocated_get_parameters_res(::flwr::proto::ClientMessage_GetParametersRes* get_parameters_res);
  private:
  const ::flwr::proto::ClientMessage_GetParametersRes& _internal_get_parameters_res() const;
  ::flwr::proto::ClientMessage_GetParametersRes* _internal_mutable_get_parameters_res();
  public:
  void unsafe_arena_set_allocated_get_parameters_res(
      ::flwr::proto::ClientMessage_GetParametersRes* get_parameters_res);
  ::flwr::proto::ClientMessage_GetParametersRes* unsafe_arena_release_get_parameters_res();

  // .flwr.proto.ClientMessage.FitRes fit_res = 4;
  bool has_fit_res() const;
  private:
  bool _internal_has_fit_res() const;
  public:
  void clear_fit_res();
  const ::flwr::proto::ClientMessage_FitRes& fit_res() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ClientMessage_FitRes* release_fit_res();
  ::flwr::proto::ClientMessage_FitRes* mutable_fit_res();
  void set_allocated_fit_res(::flwr::proto::ClientMessage_FitRes* fit_res);
  private:
  const ::flwr::proto::ClientMessage_FitRes& _internal_fit_res() const;
  ::flwr::proto::ClientMessage_FitRes* _internal_mutable_fit_res();
  public:
  void unsafe_arena_set_allocated_fit_res(
      ::flwr::proto::ClientMessage_FitRes* fit_res);
  ::flwr::proto::ClientMessage_FitRes* unsafe_arena_release_fit_res();

  // .flwr.proto.ClientMessage.EvaluateRes evaluate_res = 5;
  bool has_evaluate_res() const;
  private:
  bool _internal_has_evaluate_res() const;
  public:
  void clear_evaluate_res();
  const ::flwr::proto::ClientMessage_EvaluateRes& evaluate_res() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::ClientMessage_EvaluateRes* release_evaluate_res();
  ::flwr::proto::ClientMessage_EvaluateRes* mutable_evaluate_res();
  void set_allocated_evaluate_res(::flwr::proto::ClientMessage_EvaluateRes* evaluate_res);
  private:
  const ::flwr::proto::ClientMessage_EvaluateRes& _internal_evaluate_res() const;
  ::flwr::proto::ClientMessage_EvaluateRes* _internal_mutable_evaluate_res();
  public:
  void unsafe_arena_set_allocated_evaluate_res(
      ::flwr::proto::ClientMessage_EvaluateRes* evaluate_res);
  ::flwr::proto::ClientMessage_EvaluateRes* unsafe_arena_release_evaluate_res();

  void clear_msg();
  MsgCase msg_case() const;
  // @@protoc_insertion_point(class_scope:flwr.proto.ClientMessage)
 private:
  class _Internal;
  void set_has_disconnect_res();
  void set_has_get_properties_res();
  void set_has_get_parameters_res();
  void set_has_fit_res();
  void set_has_evaluate_res();

  inline bool has_msg() const;
  inline void clear_has_msg();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union MsgUnion {
    constexpr MsgUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::flwr::proto::ClientMessage_DisconnectRes* disconnect_res_;
    ::flwr::proto::ClientMessage_GetPropertiesRes* get_properties_res_;
    ::flwr::proto::ClientMessage_GetParametersRes* get_parameters_res_;
    ::flwr::proto::ClientMessage_FitRes* fit_res_;
    ::flwr::proto::ClientMessage_EvaluateRes* evaluate_res_;
  } msg_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Scalar& operator=(const Scalar& from) {
    CopyFrom(from);
    return *this;
  }
  inline Scalar& operator=(Scalar&& 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 Scalar& default_instance() {
    return *internal_default_instance();
  }
  enum ScalarCase {
    kDouble = 1,
    kSint64 = 8,
    kBool = 13,
    kString = 14,
    kBytes = 15,
    SCALAR_NOT_SET = 0,
  };

  static inline const Scalar* internal_default_instance() {
    return reinterpret_cast<const Scalar*>(
               &_Scalar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

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

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

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

  Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Scalar>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Scalar& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Scalar& 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(Scalar* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Scalar";
  }
  protected:
  explicit Scalar(::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 = 8,
    kBoolFieldNumber = 13,
    kStringFieldNumber = 14,
    kBytesFieldNumber = 15,
  };
  // 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 = 8;
  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 = 13;
  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 = 14;
  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 = 15;
  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:

  void clear_scalar();
  ScalarCase scalar_case() const;
  // @@protoc_insertion_point(class_scope:flwr.proto.Scalar)
 private:
  class _Internal;
  void set_has_double_();
  void set_has_sint64();
  void set_has_bool_();
  void set_has_string();
  void set_has_bytes();

  inline bool has_scalar() const;
  inline void clear_has_scalar();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union ScalarUnion {
    constexpr ScalarUnion() : _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_;
  } scalar_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_flwr_2fproto_2ftransport_2eproto;
};
// ===================================================================


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

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

// .flwr.proto.Code code = 1;
inline void Status::clear_code() {
  code_ = 0;
}
inline ::flwr::proto::Code Status::_internal_code() const {
  return static_cast< ::flwr::proto::Code >(code_);
}
inline ::flwr::proto::Code Status::code() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Status.code)
  return _internal_code();
}
inline void Status::_internal_set_code(::flwr::proto::Code value) {
  
  code_ = value;
}
inline void Status::set_code(::flwr::proto::Code value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Status.code)
}

// string message = 2;
inline void Status::clear_message() {
  message_.ClearToEmpty();
}
inline const std::string& Status::message() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Status.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Status::set_message(ArgT0&& arg0, ArgT... args) {
 
 message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Status.message)
}
inline std::string* Status::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Status.message)
  return _s;
}
inline const std::string& Status::_internal_message() const {
  return message_.Get();
}
inline void Status::_internal_set_message(const std::string& value) {
  
  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Status::_internal_mutable_message() {
  
  return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Status::release_message() {
  // @@protoc_insertion_point(field_release:flwr.proto.Status.message)
  return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Status::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Status.message)
}

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

// Parameters

// repeated bytes tensors = 1;
inline int Parameters::_internal_tensors_size() const {
  return tensors_.size();
}
inline int Parameters::tensors_size() const {
  return _internal_tensors_size();
}
inline void Parameters::clear_tensors() {
  tensors_.Clear();
}
inline std::string* Parameters::add_tensors() {
  std::string* _s = _internal_add_tensors();
  // @@protoc_insertion_point(field_add_mutable:flwr.proto.Parameters.tensors)
  return _s;
}
inline const std::string& Parameters::_internal_tensors(int index) const {
  return tensors_.Get(index);
}
inline const std::string& Parameters::tensors(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.Parameters.tensors)
  return _internal_tensors(index);
}
inline std::string* Parameters::mutable_tensors(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.Parameters.tensors)
  return tensors_.Mutable(index);
}
inline void Parameters::set_tensors(int index, const std::string& value) {
  tensors_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Parameters.tensors)
}
inline void Parameters::set_tensors(int index, std::string&& value) {
  tensors_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:flwr.proto.Parameters.tensors)
}
inline void Parameters::set_tensors(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  tensors_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:flwr.proto.Parameters.tensors)
}
inline void Parameters::set_tensors(int index, const void* value, size_t size) {
  tensors_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:flwr.proto.Parameters.tensors)
}
inline std::string* Parameters::_internal_add_tensors() {
  return tensors_.Add();
}
inline void Parameters::add_tensors(const std::string& value) {
  tensors_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:flwr.proto.Parameters.tensors)
}
inline void Parameters::add_tensors(std::string&& value) {
  tensors_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:flwr.proto.Parameters.tensors)
}
inline void Parameters::add_tensors(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  tensors_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:flwr.proto.Parameters.tensors)
}
inline void Parameters::add_tensors(const void* value, size_t size) {
  tensors_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:flwr.proto.Parameters.tensors)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Parameters::tensors() const {
  // @@protoc_insertion_point(field_list:flwr.proto.Parameters.tensors)
  return tensors_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Parameters::mutable_tensors() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.Parameters.tensors)
  return &tensors_;
}

// string tensor_type = 2;
inline void Parameters::clear_tensor_type() {
  tensor_type_.ClearToEmpty();
}
inline const std::string& Parameters::tensor_type() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Parameters.tensor_type)
  return _internal_tensor_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Parameters::set_tensor_type(ArgT0&& arg0, ArgT... args) {
 
 tensor_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Parameters.tensor_type)
}
inline std::string* Parameters::mutable_tensor_type() {
  std::string* _s = _internal_mutable_tensor_type();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Parameters.tensor_type)
  return _s;
}
inline const std::string& Parameters::_internal_tensor_type() const {
  return tensor_type_.Get();
}
inline void Parameters::_internal_set_tensor_type(const std::string& value) {
  
  tensor_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Parameters::_internal_mutable_tensor_type() {
  
  return tensor_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Parameters::release_tensor_type() {
  // @@protoc_insertion_point(field_release:flwr.proto.Parameters.tensor_type)
  return tensor_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Parameters::set_allocated_tensor_type(std::string* tensor_type) {
  if (tensor_type != nullptr) {
    
  } else {
    
  }
  tensor_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensor_type,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Parameters.tensor_type)
}

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

// ServerMessage_ReconnectIns

// int64 seconds = 1;
inline void ServerMessage_ReconnectIns::clear_seconds() {
  seconds_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ServerMessage_ReconnectIns::_internal_seconds() const {
  return seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ServerMessage_ReconnectIns::seconds() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.ReconnectIns.seconds)
  return _internal_seconds();
}
inline void ServerMessage_ReconnectIns::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  seconds_ = value;
}
inline void ServerMessage_ReconnectIns::set_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_seconds(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ServerMessage.ReconnectIns.seconds)
}

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

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

// ServerMessage_GetPropertiesIns

// map<string, .flwr.proto.Scalar> config = 1;
inline int ServerMessage_GetPropertiesIns::_internal_config_size() const {
  return config_.size();
}
inline int ServerMessage_GetPropertiesIns::config_size() const {
  return _internal_config_size();
}
inline void ServerMessage_GetPropertiesIns::clear_config() {
  config_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_GetPropertiesIns::_internal_config() const {
  return config_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_GetPropertiesIns::config() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ServerMessage.GetPropertiesIns.config)
  return _internal_config();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_GetPropertiesIns::_internal_mutable_config() {
  return config_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_GetPropertiesIns::mutable_config() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ServerMessage.GetPropertiesIns.config)
  return _internal_mutable_config();
}

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

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

// ServerMessage_GetParametersIns

// map<string, .flwr.proto.Scalar> config = 1;
inline int ServerMessage_GetParametersIns::_internal_config_size() const {
  return config_.size();
}
inline int ServerMessage_GetParametersIns::config_size() const {
  return _internal_config_size();
}
inline void ServerMessage_GetParametersIns::clear_config() {
  config_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_GetParametersIns::_internal_config() const {
  return config_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_GetParametersIns::config() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ServerMessage.GetParametersIns.config)
  return _internal_config();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_GetParametersIns::_internal_mutable_config() {
  return config_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_GetParametersIns::mutable_config() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ServerMessage.GetParametersIns.config)
  return _internal_mutable_config();
}

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

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

// ServerMessage_FitIns

// .flwr.proto.Parameters parameters = 1;
inline bool ServerMessage_FitIns::_internal_has_parameters() const {
  return this != internal_default_instance() && parameters_ != nullptr;
}
inline bool ServerMessage_FitIns::has_parameters() const {
  return _internal_has_parameters();
}
inline void ServerMessage_FitIns::clear_parameters() {
  if (GetArenaForAllocation() == nullptr && parameters_ != nullptr) {
    delete parameters_;
  }
  parameters_ = nullptr;
}
inline const ::flwr::proto::Parameters& ServerMessage_FitIns::_internal_parameters() const {
  const ::flwr::proto::Parameters* p = parameters_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Parameters&>(
      ::flwr::proto::_Parameters_default_instance_);
}
inline const ::flwr::proto::Parameters& ServerMessage_FitIns::parameters() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.FitIns.parameters)
  return _internal_parameters();
}
inline void ServerMessage_FitIns::unsafe_arena_set_allocated_parameters(
    ::flwr::proto::Parameters* parameters) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameters_);
  }
  parameters_ = parameters;
  if (parameters) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.FitIns.parameters)
}
inline ::flwr::proto::Parameters* ServerMessage_FitIns::release_parameters() {
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Parameters* ServerMessage_FitIns::unsafe_arena_release_parameters() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.FitIns.parameters)
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
  return temp;
}
inline ::flwr::proto::Parameters* ServerMessage_FitIns::_internal_mutable_parameters() {
  
  if (parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Parameters>(GetArenaForAllocation());
    parameters_ = p;
  }
  return parameters_;
}
inline ::flwr::proto::Parameters* ServerMessage_FitIns::mutable_parameters() {
  ::flwr::proto::Parameters* _msg = _internal_mutable_parameters();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.FitIns.parameters)
  return _msg;
}
inline void ServerMessage_FitIns::set_allocated_parameters(::flwr::proto::Parameters* parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete parameters_;
  }
  if (parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Parameters>::GetOwningArena(parameters);
    if (message_arena != submessage_arena) {
      parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameters, submessage_arena);
    }
    
  } else {
    
  }
  parameters_ = parameters;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ServerMessage.FitIns.parameters)
}

// map<string, .flwr.proto.Scalar> config = 2;
inline int ServerMessage_FitIns::_internal_config_size() const {
  return config_.size();
}
inline int ServerMessage_FitIns::config_size() const {
  return _internal_config_size();
}
inline void ServerMessage_FitIns::clear_config() {
  config_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_FitIns::_internal_config() const {
  return config_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_FitIns::config() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ServerMessage.FitIns.config)
  return _internal_config();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_FitIns::_internal_mutable_config() {
  return config_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_FitIns::mutable_config() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ServerMessage.FitIns.config)
  return _internal_mutable_config();
}

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

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

// ServerMessage_EvaluateIns

// .flwr.proto.Parameters parameters = 1;
inline bool ServerMessage_EvaluateIns::_internal_has_parameters() const {
  return this != internal_default_instance() && parameters_ != nullptr;
}
inline bool ServerMessage_EvaluateIns::has_parameters() const {
  return _internal_has_parameters();
}
inline void ServerMessage_EvaluateIns::clear_parameters() {
  if (GetArenaForAllocation() == nullptr && parameters_ != nullptr) {
    delete parameters_;
  }
  parameters_ = nullptr;
}
inline const ::flwr::proto::Parameters& ServerMessage_EvaluateIns::_internal_parameters() const {
  const ::flwr::proto::Parameters* p = parameters_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Parameters&>(
      ::flwr::proto::_Parameters_default_instance_);
}
inline const ::flwr::proto::Parameters& ServerMessage_EvaluateIns::parameters() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.EvaluateIns.parameters)
  return _internal_parameters();
}
inline void ServerMessage_EvaluateIns::unsafe_arena_set_allocated_parameters(
    ::flwr::proto::Parameters* parameters) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameters_);
  }
  parameters_ = parameters;
  if (parameters) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.EvaluateIns.parameters)
}
inline ::flwr::proto::Parameters* ServerMessage_EvaluateIns::release_parameters() {
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Parameters* ServerMessage_EvaluateIns::unsafe_arena_release_parameters() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.EvaluateIns.parameters)
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
  return temp;
}
inline ::flwr::proto::Parameters* ServerMessage_EvaluateIns::_internal_mutable_parameters() {
  
  if (parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Parameters>(GetArenaForAllocation());
    parameters_ = p;
  }
  return parameters_;
}
inline ::flwr::proto::Parameters* ServerMessage_EvaluateIns::mutable_parameters() {
  ::flwr::proto::Parameters* _msg = _internal_mutable_parameters();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.EvaluateIns.parameters)
  return _msg;
}
inline void ServerMessage_EvaluateIns::set_allocated_parameters(::flwr::proto::Parameters* parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete parameters_;
  }
  if (parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Parameters>::GetOwningArena(parameters);
    if (message_arena != submessage_arena) {
      parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameters, submessage_arena);
    }
    
  } else {
    
  }
  parameters_ = parameters;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ServerMessage.EvaluateIns.parameters)
}

// map<string, .flwr.proto.Scalar> config = 2;
inline int ServerMessage_EvaluateIns::_internal_config_size() const {
  return config_.size();
}
inline int ServerMessage_EvaluateIns::config_size() const {
  return _internal_config_size();
}
inline void ServerMessage_EvaluateIns::clear_config() {
  config_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_EvaluateIns::_internal_config() const {
  return config_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ServerMessage_EvaluateIns::config() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ServerMessage.EvaluateIns.config)
  return _internal_config();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_EvaluateIns::_internal_mutable_config() {
  return config_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ServerMessage_EvaluateIns::mutable_config() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ServerMessage.EvaluateIns.config)
  return _internal_mutable_config();
}

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

// ServerMessage

// .flwr.proto.ServerMessage.ReconnectIns reconnect_ins = 1;
inline bool ServerMessage::_internal_has_reconnect_ins() const {
  return msg_case() == kReconnectIns;
}
inline bool ServerMessage::has_reconnect_ins() const {
  return _internal_has_reconnect_ins();
}
inline void ServerMessage::set_has_reconnect_ins() {
  _oneof_case_[0] = kReconnectIns;
}
inline void ServerMessage::clear_reconnect_ins() {
  if (_internal_has_reconnect_ins()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.reconnect_ins_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ServerMessage_ReconnectIns* ServerMessage::release_reconnect_ins() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.reconnect_ins)
  if (_internal_has_reconnect_ins()) {
    clear_has_msg();
      ::flwr::proto::ServerMessage_ReconnectIns* temp = msg_.reconnect_ins_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.reconnect_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ServerMessage_ReconnectIns& ServerMessage::_internal_reconnect_ins() const {
  return _internal_has_reconnect_ins()
      ? *msg_.reconnect_ins_
      : reinterpret_cast< ::flwr::proto::ServerMessage_ReconnectIns&>(::flwr::proto::_ServerMessage_ReconnectIns_default_instance_);
}
inline const ::flwr::proto::ServerMessage_ReconnectIns& ServerMessage::reconnect_ins() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.reconnect_ins)
  return _internal_reconnect_ins();
}
inline ::flwr::proto::ServerMessage_ReconnectIns* ServerMessage::unsafe_arena_release_reconnect_ins() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ServerMessage.reconnect_ins)
  if (_internal_has_reconnect_ins()) {
    clear_has_msg();
    ::flwr::proto::ServerMessage_ReconnectIns* temp = msg_.reconnect_ins_;
    msg_.reconnect_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerMessage::unsafe_arena_set_allocated_reconnect_ins(::flwr::proto::ServerMessage_ReconnectIns* reconnect_ins) {
  clear_msg();
  if (reconnect_ins) {
    set_has_reconnect_ins();
    msg_.reconnect_ins_ = reconnect_ins;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.reconnect_ins)
}
inline ::flwr::proto::ServerMessage_ReconnectIns* ServerMessage::_internal_mutable_reconnect_ins() {
  if (!_internal_has_reconnect_ins()) {
    clear_msg();
    set_has_reconnect_ins();
    msg_.reconnect_ins_ = CreateMaybeMessage< ::flwr::proto::ServerMessage_ReconnectIns >(GetArenaForAllocation());
  }
  return msg_.reconnect_ins_;
}
inline ::flwr::proto::ServerMessage_ReconnectIns* ServerMessage::mutable_reconnect_ins() {
  ::flwr::proto::ServerMessage_ReconnectIns* _msg = _internal_mutable_reconnect_ins();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.reconnect_ins)
  return _msg;
}

// .flwr.proto.ServerMessage.GetPropertiesIns get_properties_ins = 2;
inline bool ServerMessage::_internal_has_get_properties_ins() const {
  return msg_case() == kGetPropertiesIns;
}
inline bool ServerMessage::has_get_properties_ins() const {
  return _internal_has_get_properties_ins();
}
inline void ServerMessage::set_has_get_properties_ins() {
  _oneof_case_[0] = kGetPropertiesIns;
}
inline void ServerMessage::clear_get_properties_ins() {
  if (_internal_has_get_properties_ins()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.get_properties_ins_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ServerMessage_GetPropertiesIns* ServerMessage::release_get_properties_ins() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.get_properties_ins)
  if (_internal_has_get_properties_ins()) {
    clear_has_msg();
      ::flwr::proto::ServerMessage_GetPropertiesIns* temp = msg_.get_properties_ins_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.get_properties_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ServerMessage_GetPropertiesIns& ServerMessage::_internal_get_properties_ins() const {
  return _internal_has_get_properties_ins()
      ? *msg_.get_properties_ins_
      : reinterpret_cast< ::flwr::proto::ServerMessage_GetPropertiesIns&>(::flwr::proto::_ServerMessage_GetPropertiesIns_default_instance_);
}
inline const ::flwr::proto::ServerMessage_GetPropertiesIns& ServerMessage::get_properties_ins() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.get_properties_ins)
  return _internal_get_properties_ins();
}
inline ::flwr::proto::ServerMessage_GetPropertiesIns* ServerMessage::unsafe_arena_release_get_properties_ins() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ServerMessage.get_properties_ins)
  if (_internal_has_get_properties_ins()) {
    clear_has_msg();
    ::flwr::proto::ServerMessage_GetPropertiesIns* temp = msg_.get_properties_ins_;
    msg_.get_properties_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerMessage::unsafe_arena_set_allocated_get_properties_ins(::flwr::proto::ServerMessage_GetPropertiesIns* get_properties_ins) {
  clear_msg();
  if (get_properties_ins) {
    set_has_get_properties_ins();
    msg_.get_properties_ins_ = get_properties_ins;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.get_properties_ins)
}
inline ::flwr::proto::ServerMessage_GetPropertiesIns* ServerMessage::_internal_mutable_get_properties_ins() {
  if (!_internal_has_get_properties_ins()) {
    clear_msg();
    set_has_get_properties_ins();
    msg_.get_properties_ins_ = CreateMaybeMessage< ::flwr::proto::ServerMessage_GetPropertiesIns >(GetArenaForAllocation());
  }
  return msg_.get_properties_ins_;
}
inline ::flwr::proto::ServerMessage_GetPropertiesIns* ServerMessage::mutable_get_properties_ins() {
  ::flwr::proto::ServerMessage_GetPropertiesIns* _msg = _internal_mutable_get_properties_ins();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.get_properties_ins)
  return _msg;
}

// .flwr.proto.ServerMessage.GetParametersIns get_parameters_ins = 3;
inline bool ServerMessage::_internal_has_get_parameters_ins() const {
  return msg_case() == kGetParametersIns;
}
inline bool ServerMessage::has_get_parameters_ins() const {
  return _internal_has_get_parameters_ins();
}
inline void ServerMessage::set_has_get_parameters_ins() {
  _oneof_case_[0] = kGetParametersIns;
}
inline void ServerMessage::clear_get_parameters_ins() {
  if (_internal_has_get_parameters_ins()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.get_parameters_ins_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ServerMessage_GetParametersIns* ServerMessage::release_get_parameters_ins() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.get_parameters_ins)
  if (_internal_has_get_parameters_ins()) {
    clear_has_msg();
      ::flwr::proto::ServerMessage_GetParametersIns* temp = msg_.get_parameters_ins_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.get_parameters_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ServerMessage_GetParametersIns& ServerMessage::_internal_get_parameters_ins() const {
  return _internal_has_get_parameters_ins()
      ? *msg_.get_parameters_ins_
      : reinterpret_cast< ::flwr::proto::ServerMessage_GetParametersIns&>(::flwr::proto::_ServerMessage_GetParametersIns_default_instance_);
}
inline const ::flwr::proto::ServerMessage_GetParametersIns& ServerMessage::get_parameters_ins() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.get_parameters_ins)
  return _internal_get_parameters_ins();
}
inline ::flwr::proto::ServerMessage_GetParametersIns* ServerMessage::unsafe_arena_release_get_parameters_ins() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ServerMessage.get_parameters_ins)
  if (_internal_has_get_parameters_ins()) {
    clear_has_msg();
    ::flwr::proto::ServerMessage_GetParametersIns* temp = msg_.get_parameters_ins_;
    msg_.get_parameters_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerMessage::unsafe_arena_set_allocated_get_parameters_ins(::flwr::proto::ServerMessage_GetParametersIns* get_parameters_ins) {
  clear_msg();
  if (get_parameters_ins) {
    set_has_get_parameters_ins();
    msg_.get_parameters_ins_ = get_parameters_ins;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.get_parameters_ins)
}
inline ::flwr::proto::ServerMessage_GetParametersIns* ServerMessage::_internal_mutable_get_parameters_ins() {
  if (!_internal_has_get_parameters_ins()) {
    clear_msg();
    set_has_get_parameters_ins();
    msg_.get_parameters_ins_ = CreateMaybeMessage< ::flwr::proto::ServerMessage_GetParametersIns >(GetArenaForAllocation());
  }
  return msg_.get_parameters_ins_;
}
inline ::flwr::proto::ServerMessage_GetParametersIns* ServerMessage::mutable_get_parameters_ins() {
  ::flwr::proto::ServerMessage_GetParametersIns* _msg = _internal_mutable_get_parameters_ins();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.get_parameters_ins)
  return _msg;
}

// .flwr.proto.ServerMessage.FitIns fit_ins = 4;
inline bool ServerMessage::_internal_has_fit_ins() const {
  return msg_case() == kFitIns;
}
inline bool ServerMessage::has_fit_ins() const {
  return _internal_has_fit_ins();
}
inline void ServerMessage::set_has_fit_ins() {
  _oneof_case_[0] = kFitIns;
}
inline void ServerMessage::clear_fit_ins() {
  if (_internal_has_fit_ins()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.fit_ins_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ServerMessage_FitIns* ServerMessage::release_fit_ins() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.fit_ins)
  if (_internal_has_fit_ins()) {
    clear_has_msg();
      ::flwr::proto::ServerMessage_FitIns* temp = msg_.fit_ins_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.fit_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ServerMessage_FitIns& ServerMessage::_internal_fit_ins() const {
  return _internal_has_fit_ins()
      ? *msg_.fit_ins_
      : reinterpret_cast< ::flwr::proto::ServerMessage_FitIns&>(::flwr::proto::_ServerMessage_FitIns_default_instance_);
}
inline const ::flwr::proto::ServerMessage_FitIns& ServerMessage::fit_ins() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.fit_ins)
  return _internal_fit_ins();
}
inline ::flwr::proto::ServerMessage_FitIns* ServerMessage::unsafe_arena_release_fit_ins() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ServerMessage.fit_ins)
  if (_internal_has_fit_ins()) {
    clear_has_msg();
    ::flwr::proto::ServerMessage_FitIns* temp = msg_.fit_ins_;
    msg_.fit_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerMessage::unsafe_arena_set_allocated_fit_ins(::flwr::proto::ServerMessage_FitIns* fit_ins) {
  clear_msg();
  if (fit_ins) {
    set_has_fit_ins();
    msg_.fit_ins_ = fit_ins;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.fit_ins)
}
inline ::flwr::proto::ServerMessage_FitIns* ServerMessage::_internal_mutable_fit_ins() {
  if (!_internal_has_fit_ins()) {
    clear_msg();
    set_has_fit_ins();
    msg_.fit_ins_ = CreateMaybeMessage< ::flwr::proto::ServerMessage_FitIns >(GetArenaForAllocation());
  }
  return msg_.fit_ins_;
}
inline ::flwr::proto::ServerMessage_FitIns* ServerMessage::mutable_fit_ins() {
  ::flwr::proto::ServerMessage_FitIns* _msg = _internal_mutable_fit_ins();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.fit_ins)
  return _msg;
}

// .flwr.proto.ServerMessage.EvaluateIns evaluate_ins = 5;
inline bool ServerMessage::_internal_has_evaluate_ins() const {
  return msg_case() == kEvaluateIns;
}
inline bool ServerMessage::has_evaluate_ins() const {
  return _internal_has_evaluate_ins();
}
inline void ServerMessage::set_has_evaluate_ins() {
  _oneof_case_[0] = kEvaluateIns;
}
inline void ServerMessage::clear_evaluate_ins() {
  if (_internal_has_evaluate_ins()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.evaluate_ins_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ServerMessage_EvaluateIns* ServerMessage::release_evaluate_ins() {
  // @@protoc_insertion_point(field_release:flwr.proto.ServerMessage.evaluate_ins)
  if (_internal_has_evaluate_ins()) {
    clear_has_msg();
      ::flwr::proto::ServerMessage_EvaluateIns* temp = msg_.evaluate_ins_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.evaluate_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ServerMessage_EvaluateIns& ServerMessage::_internal_evaluate_ins() const {
  return _internal_has_evaluate_ins()
      ? *msg_.evaluate_ins_
      : reinterpret_cast< ::flwr::proto::ServerMessage_EvaluateIns&>(::flwr::proto::_ServerMessage_EvaluateIns_default_instance_);
}
inline const ::flwr::proto::ServerMessage_EvaluateIns& ServerMessage::evaluate_ins() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ServerMessage.evaluate_ins)
  return _internal_evaluate_ins();
}
inline ::flwr::proto::ServerMessage_EvaluateIns* ServerMessage::unsafe_arena_release_evaluate_ins() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ServerMessage.evaluate_ins)
  if (_internal_has_evaluate_ins()) {
    clear_has_msg();
    ::flwr::proto::ServerMessage_EvaluateIns* temp = msg_.evaluate_ins_;
    msg_.evaluate_ins_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerMessage::unsafe_arena_set_allocated_evaluate_ins(::flwr::proto::ServerMessage_EvaluateIns* evaluate_ins) {
  clear_msg();
  if (evaluate_ins) {
    set_has_evaluate_ins();
    msg_.evaluate_ins_ = evaluate_ins;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ServerMessage.evaluate_ins)
}
inline ::flwr::proto::ServerMessage_EvaluateIns* ServerMessage::_internal_mutable_evaluate_ins() {
  if (!_internal_has_evaluate_ins()) {
    clear_msg();
    set_has_evaluate_ins();
    msg_.evaluate_ins_ = CreateMaybeMessage< ::flwr::proto::ServerMessage_EvaluateIns >(GetArenaForAllocation());
  }
  return msg_.evaluate_ins_;
}
inline ::flwr::proto::ServerMessage_EvaluateIns* ServerMessage::mutable_evaluate_ins() {
  ::flwr::proto::ServerMessage_EvaluateIns* _msg = _internal_mutable_evaluate_ins();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ServerMessage.evaluate_ins)
  return _msg;
}

inline bool ServerMessage::has_msg() const {
  return msg_case() != MSG_NOT_SET;
}
inline void ServerMessage::clear_has_msg() {
  _oneof_case_[0] = MSG_NOT_SET;
}
inline ServerMessage::MsgCase ServerMessage::msg_case() const {
  return ServerMessage::MsgCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ClientMessage_DisconnectRes

// .flwr.proto.Reason reason = 1;
inline void ClientMessage_DisconnectRes::clear_reason() {
  reason_ = 0;
}
inline ::flwr::proto::Reason ClientMessage_DisconnectRes::_internal_reason() const {
  return static_cast< ::flwr::proto::Reason >(reason_);
}
inline ::flwr::proto::Reason ClientMessage_DisconnectRes::reason() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.DisconnectRes.reason)
  return _internal_reason();
}
inline void ClientMessage_DisconnectRes::_internal_set_reason(::flwr::proto::Reason value) {
  
  reason_ = value;
}
inline void ClientMessage_DisconnectRes::set_reason(::flwr::proto::Reason value) {
  _internal_set_reason(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ClientMessage.DisconnectRes.reason)
}

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

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

// ClientMessage_GetPropertiesRes

// .flwr.proto.Status status = 1;
inline bool ClientMessage_GetPropertiesRes::_internal_has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline bool ClientMessage_GetPropertiesRes::has_status() const {
  return _internal_has_status();
}
inline void ClientMessage_GetPropertiesRes::clear_status() {
  if (GetArenaForAllocation() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::flwr::proto::Status& ClientMessage_GetPropertiesRes::_internal_status() const {
  const ::flwr::proto::Status* p = status_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Status&>(
      ::flwr::proto::_Status_default_instance_);
}
inline const ::flwr::proto::Status& ClientMessage_GetPropertiesRes::status() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.GetPropertiesRes.status)
  return _internal_status();
}
inline void ClientMessage_GetPropertiesRes::unsafe_arena_set_allocated_status(
    ::flwr::proto::Status* status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  status_ = status;
  if (status) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.GetPropertiesRes.status)
}
inline ::flwr::proto::Status* ClientMessage_GetPropertiesRes::release_status() {
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_GetPropertiesRes::unsafe_arena_release_status() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.GetPropertiesRes.status)
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_GetPropertiesRes::_internal_mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Status>(GetArenaForAllocation());
    status_ = p;
  }
  return status_;
}
inline ::flwr::proto::Status* ClientMessage_GetPropertiesRes::mutable_status() {
  ::flwr::proto::Status* _msg = _internal_mutable_status();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.GetPropertiesRes.status)
  return _msg;
}
inline void ClientMessage_GetPropertiesRes::set_allocated_status(::flwr::proto::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete status_;
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Status>::GetOwningArena(status);
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.GetPropertiesRes.status)
}

// map<string, .flwr.proto.Scalar> properties = 2;
inline int ClientMessage_GetPropertiesRes::_internal_properties_size() const {
  return properties_.size();
}
inline int ClientMessage_GetPropertiesRes::properties_size() const {
  return _internal_properties_size();
}
inline void ClientMessage_GetPropertiesRes::clear_properties() {
  properties_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ClientMessage_GetPropertiesRes::_internal_properties() const {
  return properties_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >&
ClientMessage_GetPropertiesRes::properties() const {
  // @@protoc_insertion_point(field_map:flwr.proto.ClientMessage.GetPropertiesRes.properties)
  return _internal_properties();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ClientMessage_GetPropertiesRes::_internal_mutable_properties() {
  return properties_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::flwr::proto::Scalar >*
ClientMessage_GetPropertiesRes::mutable_properties() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.ClientMessage.GetPropertiesRes.properties)
  return _internal_mutable_properties();
}

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

// ClientMessage_GetParametersRes

// .flwr.proto.Status status = 1;
inline bool ClientMessage_GetParametersRes::_internal_has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline bool ClientMessage_GetParametersRes::has_status() const {
  return _internal_has_status();
}
inline void ClientMessage_GetParametersRes::clear_status() {
  if (GetArenaForAllocation() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::flwr::proto::Status& ClientMessage_GetParametersRes::_internal_status() const {
  const ::flwr::proto::Status* p = status_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Status&>(
      ::flwr::proto::_Status_default_instance_);
}
inline const ::flwr::proto::Status& ClientMessage_GetParametersRes::status() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.GetParametersRes.status)
  return _internal_status();
}
inline void ClientMessage_GetParametersRes::unsafe_arena_set_allocated_status(
    ::flwr::proto::Status* status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  status_ = status;
  if (status) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.GetParametersRes.status)
}
inline ::flwr::proto::Status* ClientMessage_GetParametersRes::release_status() {
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_GetParametersRes::unsafe_arena_release_status() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.GetParametersRes.status)
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_GetParametersRes::_internal_mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Status>(GetArenaForAllocation());
    status_ = p;
  }
  return status_;
}
inline ::flwr::proto::Status* ClientMessage_GetParametersRes::mutable_status() {
  ::flwr::proto::Status* _msg = _internal_mutable_status();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.GetParametersRes.status)
  return _msg;
}
inline void ClientMessage_GetParametersRes::set_allocated_status(::flwr::proto::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete status_;
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Status>::GetOwningArena(status);
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.GetParametersRes.status)
}

// .flwr.proto.Parameters parameters = 2;
inline bool ClientMessage_GetParametersRes::_internal_has_parameters() const {
  return this != internal_default_instance() && parameters_ != nullptr;
}
inline bool ClientMessage_GetParametersRes::has_parameters() const {
  return _internal_has_parameters();
}
inline void ClientMessage_GetParametersRes::clear_parameters() {
  if (GetArenaForAllocation() == nullptr && parameters_ != nullptr) {
    delete parameters_;
  }
  parameters_ = nullptr;
}
inline const ::flwr::proto::Parameters& ClientMessage_GetParametersRes::_internal_parameters() const {
  const ::flwr::proto::Parameters* p = parameters_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Parameters&>(
      ::flwr::proto::_Parameters_default_instance_);
}
inline const ::flwr::proto::Parameters& ClientMessage_GetParametersRes::parameters() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.GetParametersRes.parameters)
  return _internal_parameters();
}
inline void ClientMessage_GetParametersRes::unsafe_arena_set_allocated_parameters(
    ::flwr::proto::Parameters* parameters) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameters_);
  }
  parameters_ = parameters;
  if (parameters) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.GetParametersRes.parameters)
}
inline ::flwr::proto::Parameters* ClientMessage_GetParametersRes::release_parameters() {
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Parameters* ClientMessage_GetParametersRes::unsafe_arena_release_parameters() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.GetParametersRes.parameters)
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
  return temp;
}
inline ::flwr::proto::Parameters* ClientMessage_GetParametersRes::_internal_mutable_parameters() {
  
  if (parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Parameters>(GetArenaForAllocation());
    parameters_ = p;
  }
  return parameters_;
}
inline ::flwr::proto::Parameters* ClientMessage_GetParametersRes::mutable_parameters() {
  ::flwr::proto::Parameters* _msg = _internal_mutable_parameters();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.GetParametersRes.parameters)
  return _msg;
}
inline void ClientMessage_GetParametersRes::set_allocated_parameters(::flwr::proto::Parameters* parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete parameters_;
  }
  if (parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Parameters>::GetOwningArena(parameters);
    if (message_arena != submessage_arena) {
      parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameters, submessage_arena);
    }
    
  } else {
    
  }
  parameters_ = parameters;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.GetParametersRes.parameters)
}

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

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

// ClientMessage_FitRes

// .flwr.proto.Status status = 1;
inline bool ClientMessage_FitRes::_internal_has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline bool ClientMessage_FitRes::has_status() const {
  return _internal_has_status();
}
inline void ClientMessage_FitRes::clear_status() {
  if (GetArenaForAllocation() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::flwr::proto::Status& ClientMessage_FitRes::_internal_status() const {
  const ::flwr::proto::Status* p = status_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Status&>(
      ::flwr::proto::_Status_default_instance_);
}
inline const ::flwr::proto::Status& ClientMessage_FitRes::status() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.FitRes.status)
  return _internal_status();
}
inline void ClientMessage_FitRes::unsafe_arena_set_allocated_status(
    ::flwr::proto::Status* status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  status_ = status;
  if (status) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.FitRes.status)
}
inline ::flwr::proto::Status* ClientMessage_FitRes::release_status() {
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_FitRes::unsafe_arena_release_status() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.FitRes.status)
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_FitRes::_internal_mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Status>(GetArenaForAllocation());
    status_ = p;
  }
  return status_;
}
inline ::flwr::proto::Status* ClientMessage_FitRes::mutable_status() {
  ::flwr::proto::Status* _msg = _internal_mutable_status();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.FitRes.status)
  return _msg;
}
inline void ClientMessage_FitRes::set_allocated_status(::flwr::proto::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete status_;
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Status>::GetOwningArena(status);
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.FitRes.status)
}

// .flwr.proto.Parameters parameters = 2;
inline bool ClientMessage_FitRes::_internal_has_parameters() const {
  return this != internal_default_instance() && parameters_ != nullptr;
}
inline bool ClientMessage_FitRes::has_parameters() const {
  return _internal_has_parameters();
}
inline void ClientMessage_FitRes::clear_parameters() {
  if (GetArenaForAllocation() == nullptr && parameters_ != nullptr) {
    delete parameters_;
  }
  parameters_ = nullptr;
}
inline const ::flwr::proto::Parameters& ClientMessage_FitRes::_internal_parameters() const {
  const ::flwr::proto::Parameters* p = parameters_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Parameters&>(
      ::flwr::proto::_Parameters_default_instance_);
}
inline const ::flwr::proto::Parameters& ClientMessage_FitRes::parameters() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.FitRes.parameters)
  return _internal_parameters();
}
inline void ClientMessage_FitRes::unsafe_arena_set_allocated_parameters(
    ::flwr::proto::Parameters* parameters) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameters_);
  }
  parameters_ = parameters;
  if (parameters) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.FitRes.parameters)
}
inline ::flwr::proto::Parameters* ClientMessage_FitRes::release_parameters() {
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Parameters* ClientMessage_FitRes::unsafe_arena_release_parameters() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.FitRes.parameters)
  
  ::flwr::proto::Parameters* temp = parameters_;
  parameters_ = nullptr;
  return temp;
}
inline ::flwr::proto::Parameters* ClientMessage_FitRes::_internal_mutable_parameters() {
  
  if (parameters_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Parameters>(GetArenaForAllocation());
    parameters_ = p;
  }
  return parameters_;
}
inline ::flwr::proto::Parameters* ClientMessage_FitRes::mutable_parameters() {
  ::flwr::proto::Parameters* _msg = _internal_mutable_parameters();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.FitRes.parameters)
  return _msg;
}
inline void ClientMessage_FitRes::set_allocated_parameters(::flwr::proto::Parameters* parameters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete parameters_;
  }
  if (parameters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Parameters>::GetOwningArena(parameters);
    if (message_arena != submessage_arena) {
      parameters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameters, submessage_arena);
    }
    
  } else {
    
  }
  parameters_ = parameters;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.FitRes.parameters)
}

// int64 num_examples = 3;
inline void ClientMessage_FitRes::clear_num_examples() {
  num_examples_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientMessage_FitRes::_internal_num_examples() const {
  return num_examples_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientMessage_FitRes::num_examples() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.FitRes.num_examples)
  return _internal_num_examples();
}
inline void ClientMessage_FitRes::_internal_set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  num_examples_ = value;
}
inline void ClientMessage_FitRes::set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_num_examples(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ClientMessage.FitRes.num_examples)
}

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

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

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

// ClientMessage_EvaluateRes

// .flwr.proto.Status status = 1;
inline bool ClientMessage_EvaluateRes::_internal_has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline bool ClientMessage_EvaluateRes::has_status() const {
  return _internal_has_status();
}
inline void ClientMessage_EvaluateRes::clear_status() {
  if (GetArenaForAllocation() == nullptr && status_ != nullptr) {
    delete status_;
  }
  status_ = nullptr;
}
inline const ::flwr::proto::Status& ClientMessage_EvaluateRes::_internal_status() const {
  const ::flwr::proto::Status* p = status_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Status&>(
      ::flwr::proto::_Status_default_instance_);
}
inline const ::flwr::proto::Status& ClientMessage_EvaluateRes::status() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.EvaluateRes.status)
  return _internal_status();
}
inline void ClientMessage_EvaluateRes::unsafe_arena_set_allocated_status(
    ::flwr::proto::Status* status) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  status_ = status;
  if (status) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.EvaluateRes.status)
}
inline ::flwr::proto::Status* ClientMessage_EvaluateRes::release_status() {
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_EvaluateRes::unsafe_arena_release_status() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.EvaluateRes.status)
  
  ::flwr::proto::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::flwr::proto::Status* ClientMessage_EvaluateRes::_internal_mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Status>(GetArenaForAllocation());
    status_ = p;
  }
  return status_;
}
inline ::flwr::proto::Status* ClientMessage_EvaluateRes::mutable_status() {
  ::flwr::proto::Status* _msg = _internal_mutable_status();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.EvaluateRes.status)
  return _msg;
}
inline void ClientMessage_EvaluateRes::set_allocated_status(::flwr::proto::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete status_;
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Status>::GetOwningArena(status);
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.ClientMessage.EvaluateRes.status)
}

// float loss = 2;
inline void ClientMessage_EvaluateRes::clear_loss() {
  loss_ = 0;
}
inline float ClientMessage_EvaluateRes::_internal_loss() const {
  return loss_;
}
inline float ClientMessage_EvaluateRes::loss() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.EvaluateRes.loss)
  return _internal_loss();
}
inline void ClientMessage_EvaluateRes::_internal_set_loss(float value) {
  
  loss_ = value;
}
inline void ClientMessage_EvaluateRes::set_loss(float value) {
  _internal_set_loss(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ClientMessage.EvaluateRes.loss)
}

// int64 num_examples = 3;
inline void ClientMessage_EvaluateRes::clear_num_examples() {
  num_examples_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientMessage_EvaluateRes::_internal_num_examples() const {
  return num_examples_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientMessage_EvaluateRes::num_examples() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.EvaluateRes.num_examples)
  return _internal_num_examples();
}
inline void ClientMessage_EvaluateRes::_internal_set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  num_examples_ = value;
}
inline void ClientMessage_EvaluateRes::set_num_examples(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_num_examples(value);
  // @@protoc_insertion_point(field_set:flwr.proto.ClientMessage.EvaluateRes.num_examples)
}

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

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

// ClientMessage

// .flwr.proto.ClientMessage.DisconnectRes disconnect_res = 1;
inline bool ClientMessage::_internal_has_disconnect_res() const {
  return msg_case() == kDisconnectRes;
}
inline bool ClientMessage::has_disconnect_res() const {
  return _internal_has_disconnect_res();
}
inline void ClientMessage::set_has_disconnect_res() {
  _oneof_case_[0] = kDisconnectRes;
}
inline void ClientMessage::clear_disconnect_res() {
  if (_internal_has_disconnect_res()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.disconnect_res_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ClientMessage_DisconnectRes* ClientMessage::release_disconnect_res() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.disconnect_res)
  if (_internal_has_disconnect_res()) {
    clear_has_msg();
      ::flwr::proto::ClientMessage_DisconnectRes* temp = msg_.disconnect_res_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.disconnect_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ClientMessage_DisconnectRes& ClientMessage::_internal_disconnect_res() const {
  return _internal_has_disconnect_res()
      ? *msg_.disconnect_res_
      : reinterpret_cast< ::flwr::proto::ClientMessage_DisconnectRes&>(::flwr::proto::_ClientMessage_DisconnectRes_default_instance_);
}
inline const ::flwr::proto::ClientMessage_DisconnectRes& ClientMessage::disconnect_res() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.disconnect_res)
  return _internal_disconnect_res();
}
inline ::flwr::proto::ClientMessage_DisconnectRes* ClientMessage::unsafe_arena_release_disconnect_res() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ClientMessage.disconnect_res)
  if (_internal_has_disconnect_res()) {
    clear_has_msg();
    ::flwr::proto::ClientMessage_DisconnectRes* temp = msg_.disconnect_res_;
    msg_.disconnect_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientMessage::unsafe_arena_set_allocated_disconnect_res(::flwr::proto::ClientMessage_DisconnectRes* disconnect_res) {
  clear_msg();
  if (disconnect_res) {
    set_has_disconnect_res();
    msg_.disconnect_res_ = disconnect_res;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.disconnect_res)
}
inline ::flwr::proto::ClientMessage_DisconnectRes* ClientMessage::_internal_mutable_disconnect_res() {
  if (!_internal_has_disconnect_res()) {
    clear_msg();
    set_has_disconnect_res();
    msg_.disconnect_res_ = CreateMaybeMessage< ::flwr::proto::ClientMessage_DisconnectRes >(GetArenaForAllocation());
  }
  return msg_.disconnect_res_;
}
inline ::flwr::proto::ClientMessage_DisconnectRes* ClientMessage::mutable_disconnect_res() {
  ::flwr::proto::ClientMessage_DisconnectRes* _msg = _internal_mutable_disconnect_res();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.disconnect_res)
  return _msg;
}

// .flwr.proto.ClientMessage.GetPropertiesRes get_properties_res = 2;
inline bool ClientMessage::_internal_has_get_properties_res() const {
  return msg_case() == kGetPropertiesRes;
}
inline bool ClientMessage::has_get_properties_res() const {
  return _internal_has_get_properties_res();
}
inline void ClientMessage::set_has_get_properties_res() {
  _oneof_case_[0] = kGetPropertiesRes;
}
inline void ClientMessage::clear_get_properties_res() {
  if (_internal_has_get_properties_res()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.get_properties_res_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ClientMessage_GetPropertiesRes* ClientMessage::release_get_properties_res() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.get_properties_res)
  if (_internal_has_get_properties_res()) {
    clear_has_msg();
      ::flwr::proto::ClientMessage_GetPropertiesRes* temp = msg_.get_properties_res_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.get_properties_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ClientMessage_GetPropertiesRes& ClientMessage::_internal_get_properties_res() const {
  return _internal_has_get_properties_res()
      ? *msg_.get_properties_res_
      : reinterpret_cast< ::flwr::proto::ClientMessage_GetPropertiesRes&>(::flwr::proto::_ClientMessage_GetPropertiesRes_default_instance_);
}
inline const ::flwr::proto::ClientMessage_GetPropertiesRes& ClientMessage::get_properties_res() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.get_properties_res)
  return _internal_get_properties_res();
}
inline ::flwr::proto::ClientMessage_GetPropertiesRes* ClientMessage::unsafe_arena_release_get_properties_res() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ClientMessage.get_properties_res)
  if (_internal_has_get_properties_res()) {
    clear_has_msg();
    ::flwr::proto::ClientMessage_GetPropertiesRes* temp = msg_.get_properties_res_;
    msg_.get_properties_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientMessage::unsafe_arena_set_allocated_get_properties_res(::flwr::proto::ClientMessage_GetPropertiesRes* get_properties_res) {
  clear_msg();
  if (get_properties_res) {
    set_has_get_properties_res();
    msg_.get_properties_res_ = get_properties_res;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.get_properties_res)
}
inline ::flwr::proto::ClientMessage_GetPropertiesRes* ClientMessage::_internal_mutable_get_properties_res() {
  if (!_internal_has_get_properties_res()) {
    clear_msg();
    set_has_get_properties_res();
    msg_.get_properties_res_ = CreateMaybeMessage< ::flwr::proto::ClientMessage_GetPropertiesRes >(GetArenaForAllocation());
  }
  return msg_.get_properties_res_;
}
inline ::flwr::proto::ClientMessage_GetPropertiesRes* ClientMessage::mutable_get_properties_res() {
  ::flwr::proto::ClientMessage_GetPropertiesRes* _msg = _internal_mutable_get_properties_res();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.get_properties_res)
  return _msg;
}

// .flwr.proto.ClientMessage.GetParametersRes get_parameters_res = 3;
inline bool ClientMessage::_internal_has_get_parameters_res() const {
  return msg_case() == kGetParametersRes;
}
inline bool ClientMessage::has_get_parameters_res() const {
  return _internal_has_get_parameters_res();
}
inline void ClientMessage::set_has_get_parameters_res() {
  _oneof_case_[0] = kGetParametersRes;
}
inline void ClientMessage::clear_get_parameters_res() {
  if (_internal_has_get_parameters_res()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.get_parameters_res_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ClientMessage_GetParametersRes* ClientMessage::release_get_parameters_res() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.get_parameters_res)
  if (_internal_has_get_parameters_res()) {
    clear_has_msg();
      ::flwr::proto::ClientMessage_GetParametersRes* temp = msg_.get_parameters_res_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.get_parameters_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ClientMessage_GetParametersRes& ClientMessage::_internal_get_parameters_res() const {
  return _internal_has_get_parameters_res()
      ? *msg_.get_parameters_res_
      : reinterpret_cast< ::flwr::proto::ClientMessage_GetParametersRes&>(::flwr::proto::_ClientMessage_GetParametersRes_default_instance_);
}
inline const ::flwr::proto::ClientMessage_GetParametersRes& ClientMessage::get_parameters_res() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.get_parameters_res)
  return _internal_get_parameters_res();
}
inline ::flwr::proto::ClientMessage_GetParametersRes* ClientMessage::unsafe_arena_release_get_parameters_res() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ClientMessage.get_parameters_res)
  if (_internal_has_get_parameters_res()) {
    clear_has_msg();
    ::flwr::proto::ClientMessage_GetParametersRes* temp = msg_.get_parameters_res_;
    msg_.get_parameters_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientMessage::unsafe_arena_set_allocated_get_parameters_res(::flwr::proto::ClientMessage_GetParametersRes* get_parameters_res) {
  clear_msg();
  if (get_parameters_res) {
    set_has_get_parameters_res();
    msg_.get_parameters_res_ = get_parameters_res;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.get_parameters_res)
}
inline ::flwr::proto::ClientMessage_GetParametersRes* ClientMessage::_internal_mutable_get_parameters_res() {
  if (!_internal_has_get_parameters_res()) {
    clear_msg();
    set_has_get_parameters_res();
    msg_.get_parameters_res_ = CreateMaybeMessage< ::flwr::proto::ClientMessage_GetParametersRes >(GetArenaForAllocation());
  }
  return msg_.get_parameters_res_;
}
inline ::flwr::proto::ClientMessage_GetParametersRes* ClientMessage::mutable_get_parameters_res() {
  ::flwr::proto::ClientMessage_GetParametersRes* _msg = _internal_mutable_get_parameters_res();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.get_parameters_res)
  return _msg;
}

// .flwr.proto.ClientMessage.FitRes fit_res = 4;
inline bool ClientMessage::_internal_has_fit_res() const {
  return msg_case() == kFitRes;
}
inline bool ClientMessage::has_fit_res() const {
  return _internal_has_fit_res();
}
inline void ClientMessage::set_has_fit_res() {
  _oneof_case_[0] = kFitRes;
}
inline void ClientMessage::clear_fit_res() {
  if (_internal_has_fit_res()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.fit_res_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ClientMessage_FitRes* ClientMessage::release_fit_res() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.fit_res)
  if (_internal_has_fit_res()) {
    clear_has_msg();
      ::flwr::proto::ClientMessage_FitRes* temp = msg_.fit_res_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.fit_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ClientMessage_FitRes& ClientMessage::_internal_fit_res() const {
  return _internal_has_fit_res()
      ? *msg_.fit_res_
      : reinterpret_cast< ::flwr::proto::ClientMessage_FitRes&>(::flwr::proto::_ClientMessage_FitRes_default_instance_);
}
inline const ::flwr::proto::ClientMessage_FitRes& ClientMessage::fit_res() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.fit_res)
  return _internal_fit_res();
}
inline ::flwr::proto::ClientMessage_FitRes* ClientMessage::unsafe_arena_release_fit_res() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ClientMessage.fit_res)
  if (_internal_has_fit_res()) {
    clear_has_msg();
    ::flwr::proto::ClientMessage_FitRes* temp = msg_.fit_res_;
    msg_.fit_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientMessage::unsafe_arena_set_allocated_fit_res(::flwr::proto::ClientMessage_FitRes* fit_res) {
  clear_msg();
  if (fit_res) {
    set_has_fit_res();
    msg_.fit_res_ = fit_res;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.fit_res)
}
inline ::flwr::proto::ClientMessage_FitRes* ClientMessage::_internal_mutable_fit_res() {
  if (!_internal_has_fit_res()) {
    clear_msg();
    set_has_fit_res();
    msg_.fit_res_ = CreateMaybeMessage< ::flwr::proto::ClientMessage_FitRes >(GetArenaForAllocation());
  }
  return msg_.fit_res_;
}
inline ::flwr::proto::ClientMessage_FitRes* ClientMessage::mutable_fit_res() {
  ::flwr::proto::ClientMessage_FitRes* _msg = _internal_mutable_fit_res();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.fit_res)
  return _msg;
}

// .flwr.proto.ClientMessage.EvaluateRes evaluate_res = 5;
inline bool ClientMessage::_internal_has_evaluate_res() const {
  return msg_case() == kEvaluateRes;
}
inline bool ClientMessage::has_evaluate_res() const {
  return _internal_has_evaluate_res();
}
inline void ClientMessage::set_has_evaluate_res() {
  _oneof_case_[0] = kEvaluateRes;
}
inline void ClientMessage::clear_evaluate_res() {
  if (_internal_has_evaluate_res()) {
    if (GetArenaForAllocation() == nullptr) {
      delete msg_.evaluate_res_;
    }
    clear_has_msg();
  }
}
inline ::flwr::proto::ClientMessage_EvaluateRes* ClientMessage::release_evaluate_res() {
  // @@protoc_insertion_point(field_release:flwr.proto.ClientMessage.evaluate_res)
  if (_internal_has_evaluate_res()) {
    clear_has_msg();
      ::flwr::proto::ClientMessage_EvaluateRes* temp = msg_.evaluate_res_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    msg_.evaluate_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::flwr::proto::ClientMessage_EvaluateRes& ClientMessage::_internal_evaluate_res() const {
  return _internal_has_evaluate_res()
      ? *msg_.evaluate_res_
      : reinterpret_cast< ::flwr::proto::ClientMessage_EvaluateRes&>(::flwr::proto::_ClientMessage_EvaluateRes_default_instance_);
}
inline const ::flwr::proto::ClientMessage_EvaluateRes& ClientMessage::evaluate_res() const {
  // @@protoc_insertion_point(field_get:flwr.proto.ClientMessage.evaluate_res)
  return _internal_evaluate_res();
}
inline ::flwr::proto::ClientMessage_EvaluateRes* ClientMessage::unsafe_arena_release_evaluate_res() {
  // @@protoc_insertion_point(field_unsafe_arena_release:flwr.proto.ClientMessage.evaluate_res)
  if (_internal_has_evaluate_res()) {
    clear_has_msg();
    ::flwr::proto::ClientMessage_EvaluateRes* temp = msg_.evaluate_res_;
    msg_.evaluate_res_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientMessage::unsafe_arena_set_allocated_evaluate_res(::flwr::proto::ClientMessage_EvaluateRes* evaluate_res) {
  clear_msg();
  if (evaluate_res) {
    set_has_evaluate_res();
    msg_.evaluate_res_ = evaluate_res;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.ClientMessage.evaluate_res)
}
inline ::flwr::proto::ClientMessage_EvaluateRes* ClientMessage::_internal_mutable_evaluate_res() {
  if (!_internal_has_evaluate_res()) {
    clear_msg();
    set_has_evaluate_res();
    msg_.evaluate_res_ = CreateMaybeMessage< ::flwr::proto::ClientMessage_EvaluateRes >(GetArenaForAllocation());
  }
  return msg_.evaluate_res_;
}
inline ::flwr::proto::ClientMessage_EvaluateRes* ClientMessage::mutable_evaluate_res() {
  ::flwr::proto::ClientMessage_EvaluateRes* _msg = _internal_mutable_evaluate_res();
  // @@protoc_insertion_point(field_mutable:flwr.proto.ClientMessage.evaluate_res)
  return _msg;
}

inline bool ClientMessage::has_msg() const {
  return msg_case() != MSG_NOT_SET;
}
inline void ClientMessage::clear_has_msg() {
  _oneof_case_[0] = MSG_NOT_SET;
}
inline ClientMessage::MsgCase ClientMessage::msg_case() const {
  return ClientMessage::MsgCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Scalar

// double double = 1;
inline bool Scalar::_internal_has_double_() const {
  return scalar_case() == kDouble;
}
inline bool Scalar::has_double_() const {
  return _internal_has_double_();
}
inline void Scalar::set_has_double_() {
  _oneof_case_[0] = kDouble;
}
inline void Scalar::clear_double_() {
  if (_internal_has_double_()) {
    scalar_.double__ = 0;
    clear_has_scalar();
  }
}
inline double Scalar::_internal_double_() const {
  if (_internal_has_double_()) {
    return scalar_.double__;
  }
  return 0;
}
inline void Scalar::_internal_set_double_(double value) {
  if (!_internal_has_double_()) {
    clear_scalar();
    set_has_double_();
  }
  scalar_.double__ = value;
}
inline double Scalar::double_() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Scalar.double)
  return _internal_double_();
}
inline void Scalar::set_double_(double value) {
  _internal_set_double_(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Scalar.double)
}

// sint64 sint64 = 8;
inline bool Scalar::_internal_has_sint64() const {
  return scalar_case() == kSint64;
}
inline bool Scalar::has_sint64() const {
  return _internal_has_sint64();
}
inline void Scalar::set_has_sint64() {
  _oneof_case_[0] = kSint64;
}
inline void Scalar::clear_sint64() {
  if (_internal_has_sint64()) {
    scalar_.sint64_ = int64_t{0};
    clear_has_scalar();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Scalar::_internal_sint64() const {
  if (_internal_has_sint64()) {
    return scalar_.sint64_;
  }
  return int64_t{0};
}
inline void Scalar::_internal_set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  if (!_internal_has_sint64()) {
    clear_scalar();
    set_has_sint64();
  }
  scalar_.sint64_ = value;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Scalar::sint64() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Scalar.sint64)
  return _internal_sint64();
}
inline void Scalar::set_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_sint64(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Scalar.sint64)
}

// bool bool = 13;
inline bool Scalar::_internal_has_bool_() const {
  return scalar_case() == kBool;
}
inline bool Scalar::has_bool_() const {
  return _internal_has_bool_();
}
inline void Scalar::set_has_bool_() {
  _oneof_case_[0] = kBool;
}
inline void Scalar::clear_bool_() {
  if (_internal_has_bool_()) {
    scalar_.bool__ = false;
    clear_has_scalar();
  }
}
inline bool Scalar::_internal_bool_() const {
  if (_internal_has_bool_()) {
    return scalar_.bool__;
  }
  return false;
}
inline void Scalar::_internal_set_bool_(bool value) {
  if (!_internal_has_bool_()) {
    clear_scalar();
    set_has_bool_();
  }
  scalar_.bool__ = value;
}
inline bool Scalar::bool_() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Scalar.bool)
  return _internal_bool_();
}
inline void Scalar::set_bool_(bool value) {
  _internal_set_bool_(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Scalar.bool)
}

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

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

inline bool Scalar::has_scalar() const {
  return scalar_case() != SCALAR_NOT_SET;
}
inline void Scalar::clear_has_scalar() {
  _oneof_case_[0] = SCALAR_NOT_SET;
}
inline Scalar::ScalarCase Scalar::scalar_case() const {
  return Scalar::ScalarCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace flwr

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::flwr::proto::Code> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::flwr::proto::Code>() {
  return ::flwr::proto::Code_descriptor();
}
template <> struct is_proto_enum< ::flwr::proto::Reason> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::flwr::proto::Reason>() {
  return ::flwr::proto::Reason_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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