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

#ifndef GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2ffleet_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_flwr_2fproto_2ffleet_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_bases.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
#include "flwr/proto/node.pb.h"
#include "flwr/proto/task.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_flwr_2fproto_2ffleet_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_2ffleet_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[15]
    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_2ffleet_2eproto;
namespace flwr {
namespace proto {
class CreateNodeRequest;
struct CreateNodeRequestDefaultTypeInternal;
extern CreateNodeRequestDefaultTypeInternal _CreateNodeRequest_default_instance_;
class CreateNodeResponse;
struct CreateNodeResponseDefaultTypeInternal;
extern CreateNodeResponseDefaultTypeInternal _CreateNodeResponse_default_instance_;
class DeleteNodeRequest;
struct DeleteNodeRequestDefaultTypeInternal;
extern DeleteNodeRequestDefaultTypeInternal _DeleteNodeRequest_default_instance_;
class DeleteNodeResponse;
struct DeleteNodeResponseDefaultTypeInternal;
extern DeleteNodeResponseDefaultTypeInternal _DeleteNodeResponse_default_instance_;
class GetRunRequest;
struct GetRunRequestDefaultTypeInternal;
extern GetRunRequestDefaultTypeInternal _GetRunRequest_default_instance_;
class GetRunResponse;
struct GetRunResponseDefaultTypeInternal;
extern GetRunResponseDefaultTypeInternal _GetRunResponse_default_instance_;
class PingRequest;
struct PingRequestDefaultTypeInternal;
extern PingRequestDefaultTypeInternal _PingRequest_default_instance_;
class PingResponse;
struct PingResponseDefaultTypeInternal;
extern PingResponseDefaultTypeInternal _PingResponse_default_instance_;
class PullTaskInsRequest;
struct PullTaskInsRequestDefaultTypeInternal;
extern PullTaskInsRequestDefaultTypeInternal _PullTaskInsRequest_default_instance_;
class PullTaskInsResponse;
struct PullTaskInsResponseDefaultTypeInternal;
extern PullTaskInsResponseDefaultTypeInternal _PullTaskInsResponse_default_instance_;
class PushTaskResRequest;
struct PushTaskResRequestDefaultTypeInternal;
extern PushTaskResRequestDefaultTypeInternal _PushTaskResRequest_default_instance_;
class PushTaskResResponse;
struct PushTaskResResponseDefaultTypeInternal;
extern PushTaskResResponseDefaultTypeInternal _PushTaskResResponse_default_instance_;
class PushTaskResResponse_ResultsEntry_DoNotUse;
struct PushTaskResResponse_ResultsEntry_DoNotUseDefaultTypeInternal;
extern PushTaskResResponse_ResultsEntry_DoNotUseDefaultTypeInternal _PushTaskResResponse_ResultsEntry_DoNotUse_default_instance_;
class Reconnect;
struct ReconnectDefaultTypeInternal;
extern ReconnectDefaultTypeInternal _Reconnect_default_instance_;
class Run;
struct RunDefaultTypeInternal;
extern RunDefaultTypeInternal _Run_default_instance_;
}  // namespace proto
}  // namespace flwr
PROTOBUF_NAMESPACE_OPEN
template<> ::flwr::proto::CreateNodeRequest* Arena::CreateMaybeMessage<::flwr::proto::CreateNodeRequest>(Arena*);
template<> ::flwr::proto::CreateNodeResponse* Arena::CreateMaybeMessage<::flwr::proto::CreateNodeResponse>(Arena*);
template<> ::flwr::proto::DeleteNodeRequest* Arena::CreateMaybeMessage<::flwr::proto::DeleteNodeRequest>(Arena*);
template<> ::flwr::proto::DeleteNodeResponse* Arena::CreateMaybeMessage<::flwr::proto::DeleteNodeResponse>(Arena*);
template<> ::flwr::proto::GetRunRequest* Arena::CreateMaybeMessage<::flwr::proto::GetRunRequest>(Arena*);
template<> ::flwr::proto::GetRunResponse* Arena::CreateMaybeMessage<::flwr::proto::GetRunResponse>(Arena*);
template<> ::flwr::proto::PingRequest* Arena::CreateMaybeMessage<::flwr::proto::PingRequest>(Arena*);
template<> ::flwr::proto::PingResponse* Arena::CreateMaybeMessage<::flwr::proto::PingResponse>(Arena*);
template<> ::flwr::proto::PullTaskInsRequest* Arena::CreateMaybeMessage<::flwr::proto::PullTaskInsRequest>(Arena*);
template<> ::flwr::proto::PullTaskInsResponse* Arena::CreateMaybeMessage<::flwr::proto::PullTaskInsResponse>(Arena*);
template<> ::flwr::proto::PushTaskResRequest* Arena::CreateMaybeMessage<::flwr::proto::PushTaskResRequest>(Arena*);
template<> ::flwr::proto::PushTaskResResponse* Arena::CreateMaybeMessage<::flwr::proto::PushTaskResResponse>(Arena*);
template<> ::flwr::proto::PushTaskResResponse_ResultsEntry_DoNotUse* Arena::CreateMaybeMessage<::flwr::proto::PushTaskResResponse_ResultsEntry_DoNotUse>(Arena*);
template<> ::flwr::proto::Reconnect* Arena::CreateMaybeMessage<::flwr::proto::Reconnect>(Arena*);
template<> ::flwr::proto::Run* Arena::CreateMaybeMessage<::flwr::proto::Run>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace flwr {
namespace proto {

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

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

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

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

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

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

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

  CreateNodeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateNodeRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CreateNodeRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CreateNodeRequest& 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(CreateNodeRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.CreateNodeRequest";
  }
  protected:
  explicit CreateNodeRequest(::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 {
    kPingIntervalFieldNumber = 1,
  };
  // double ping_interval = 1;
  void clear_ping_interval();
  double ping_interval() const;
  void set_ping_interval(double value);
  private:
  double _internal_ping_interval() const;
  void _internal_set_ping_interval(double value);
  public:

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

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

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

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

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

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

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

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

  CreateNodeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateNodeResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CreateNodeResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CreateNodeResponse& 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(CreateNodeResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.CreateNodeResponse";
  }
  protected:
  explicit CreateNodeResponse(::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 {
    kNodeFieldNumber = 1,
  };
  // .flwr.proto.Node node = 1;
  bool has_node() const;
  private:
  bool _internal_has_node() const;
  public:
  void clear_node();
  const ::flwr::proto::Node& node() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Node* release_node();
  ::flwr::proto::Node* mutable_node();
  void set_allocated_node(::flwr::proto::Node* node);
  private:
  const ::flwr::proto::Node& _internal_node() const;
  ::flwr::proto::Node* _internal_mutable_node();
  public:
  void unsafe_arena_set_allocated_node(
      ::flwr::proto::Node* node);
  ::flwr::proto::Node* unsafe_arena_release_node();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::flwr::proto::Node* node_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeleteNodeRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeleteNodeRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeleteNodeRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeleteNodeRequest& 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(DeleteNodeRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.DeleteNodeRequest";
  }
  protected:
  explicit DeleteNodeRequest(::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 {
    kNodeFieldNumber = 1,
  };
  // .flwr.proto.Node node = 1;
  bool has_node() const;
  private:
  bool _internal_has_node() const;
  public:
  void clear_node();
  const ::flwr::proto::Node& node() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Node* release_node();
  ::flwr::proto::Node* mutable_node();
  void set_allocated_node(::flwr::proto::Node* node);
  private:
  const ::flwr::proto::Node& _internal_node() const;
  ::flwr::proto::Node* _internal_mutable_node();
  public:
  void unsafe_arena_set_allocated_node(
      ::flwr::proto::Node* node);
  ::flwr::proto::Node* unsafe_arena_release_node();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::flwr::proto::Node* node_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeleteNodeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeleteNodeResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const DeleteNodeResponse& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const DeleteNodeResponse& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
  }
  public:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.DeleteNodeResponse";
  }
  protected:
  explicit DeleteNodeResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  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 -------------------------------------------------------

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

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

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

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

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

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

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

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

  PingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PingRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PingRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PingRequest& 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(PingRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PingRequest";
  }
  protected:
  explicit PingRequest(::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 {
    kNodeFieldNumber = 1,
    kPingIntervalFieldNumber = 2,
  };
  // .flwr.proto.Node node = 1;
  bool has_node() const;
  private:
  bool _internal_has_node() const;
  public:
  void clear_node();
  const ::flwr::proto::Node& node() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Node* release_node();
  ::flwr::proto::Node* mutable_node();
  void set_allocated_node(::flwr::proto::Node* node);
  private:
  const ::flwr::proto::Node& _internal_node() const;
  ::flwr::proto::Node* _internal_mutable_node();
  public:
  void unsafe_arena_set_allocated_node(
      ::flwr::proto::Node* node);
  ::flwr::proto::Node* unsafe_arena_release_node();

  // double ping_interval = 2;
  void clear_ping_interval();
  double ping_interval() const;
  void set_ping_interval(double value);
  private:
  double _internal_ping_interval() const;
  void _internal_set_ping_interval(double value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::flwr::proto::Node* node_;
  double ping_interval_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  PingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PingResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PingResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PingResponse& 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(PingResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PingResponse";
  }
  protected:
  explicit PingResponse(::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 {
    kSuccessFieldNumber = 1,
  };
  // bool success = 1;
  void clear_success();
  bool success() const;
  void set_success(bool value);
  private:
  bool _internal_success() const;
  void _internal_set_success(bool value);
  public:

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

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

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

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

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

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

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

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

  PullTaskInsRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PullTaskInsRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PullTaskInsRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PullTaskInsRequest& 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(PullTaskInsRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PullTaskInsRequest";
  }
  protected:
  explicit PullTaskInsRequest(::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 {
    kTaskIdsFieldNumber = 2,
    kNodeFieldNumber = 1,
  };
  // repeated string task_ids = 2;
  int task_ids_size() const;
  private:
  int _internal_task_ids_size() const;
  public:
  void clear_task_ids();
  const std::string& task_ids(int index) const;
  std::string* mutable_task_ids(int index);
  void set_task_ids(int index, const std::string& value);
  void set_task_ids(int index, std::string&& value);
  void set_task_ids(int index, const char* value);
  void set_task_ids(int index, const char* value, size_t size);
  std::string* add_task_ids();
  void add_task_ids(const std::string& value);
  void add_task_ids(std::string&& value);
  void add_task_ids(const char* value);
  void add_task_ids(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& task_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_task_ids();
  private:
  const std::string& _internal_task_ids(int index) const;
  std::string* _internal_add_task_ids();
  public:

  // .flwr.proto.Node node = 1;
  bool has_node() const;
  private:
  bool _internal_has_node() const;
  public:
  void clear_node();
  const ::flwr::proto::Node& node() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Node* release_node();
  ::flwr::proto::Node* mutable_node();
  void set_allocated_node(::flwr::proto::Node* node);
  private:
  const ::flwr::proto::Node& _internal_node() const;
  ::flwr::proto::Node* _internal_mutable_node();
  public:
  void unsafe_arena_set_allocated_node(
      ::flwr::proto::Node* node);
  ::flwr::proto::Node* unsafe_arena_release_node();

  // @@protoc_insertion_point(class_scope:flwr.proto.PullTaskInsRequest)
 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> task_ids_;
  ::flwr::proto::Node* node_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  PullTaskInsResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PullTaskInsResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PullTaskInsResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PullTaskInsResponse& 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(PullTaskInsResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PullTaskInsResponse";
  }
  protected:
  explicit PullTaskInsResponse(::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 {
    kTaskInsListFieldNumber = 2,
    kReconnectFieldNumber = 1,
  };
  // repeated .flwr.proto.TaskIns task_ins_list = 2;
  int task_ins_list_size() const;
  private:
  int _internal_task_ins_list_size() const;
  public:
  void clear_task_ins_list();
  ::flwr::proto::TaskIns* mutable_task_ins_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskIns >*
      mutable_task_ins_list();
  private:
  const ::flwr::proto::TaskIns& _internal_task_ins_list(int index) const;
  ::flwr::proto::TaskIns* _internal_add_task_ins_list();
  public:
  const ::flwr::proto::TaskIns& task_ins_list(int index) const;
  ::flwr::proto::TaskIns* add_task_ins_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskIns >&
      task_ins_list() const;

  // .flwr.proto.Reconnect reconnect = 1;
  bool has_reconnect() const;
  private:
  bool _internal_has_reconnect() const;
  public:
  void clear_reconnect();
  const ::flwr::proto::Reconnect& reconnect() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Reconnect* release_reconnect();
  ::flwr::proto::Reconnect* mutable_reconnect();
  void set_allocated_reconnect(::flwr::proto::Reconnect* reconnect);
  private:
  const ::flwr::proto::Reconnect& _internal_reconnect() const;
  ::flwr::proto::Reconnect* _internal_mutable_reconnect();
  public:
  void unsafe_arena_set_allocated_reconnect(
      ::flwr::proto::Reconnect* reconnect);
  ::flwr::proto::Reconnect* unsafe_arena_release_reconnect();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskIns > task_ins_list_;
  ::flwr::proto::Reconnect* reconnect_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  PushTaskResRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PushTaskResRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PushTaskResRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PushTaskResRequest& 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(PushTaskResRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PushTaskResRequest";
  }
  protected:
  explicit PushTaskResRequest(::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 {
    kTaskResListFieldNumber = 1,
  };
  // repeated .flwr.proto.TaskRes task_res_list = 1;
  int task_res_list_size() const;
  private:
  int _internal_task_res_list_size() const;
  public:
  void clear_task_res_list();
  ::flwr::proto::TaskRes* mutable_task_res_list(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskRes >*
      mutable_task_res_list();
  private:
  const ::flwr::proto::TaskRes& _internal_task_res_list(int index) const;
  ::flwr::proto::TaskRes* _internal_add_task_res_list();
  public:
  const ::flwr::proto::TaskRes& task_res_list(int index) const;
  ::flwr::proto::TaskRes* add_task_res_list();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskRes >&
      task_res_list() const;

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskRes > task_res_list_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

class PushTaskResResponse_ResultsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<PushTaskResResponse_ResultsEntry_DoNotUse, 
    std::string, ::PROTOBUF_NAMESPACE_ID::uint32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<PushTaskResResponse_ResultsEntry_DoNotUse, 
    std::string, ::PROTOBUF_NAMESPACE_ID::uint32,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> SuperType;
  PushTaskResResponse_ResultsEntry_DoNotUse();
  explicit constexpr PushTaskResResponse_ResultsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit PushTaskResResponse_ResultsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const PushTaskResResponse_ResultsEntry_DoNotUse& other);
  static const PushTaskResResponse_ResultsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const PushTaskResResponse_ResultsEntry_DoNotUse*>(&_PushTaskResResponse_ResultsEntry_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.PushTaskResResponse.ResultsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
};

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

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

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

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

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

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

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

  PushTaskResResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PushTaskResResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PushTaskResResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PushTaskResResponse& 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(PushTaskResResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.PushTaskResResponse";
  }
  protected:
  explicit PushTaskResResponse(::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 {
    kResultsFieldNumber = 2,
    kReconnectFieldNumber = 1,
  };
  // map<string, uint32> results = 2;
  int results_size() const;
  private:
  int _internal_results_size() const;
  public:
  void clear_results();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >&
      _internal_results() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >*
      _internal_mutable_results();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >&
      results() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >*
      mutable_results();

  // .flwr.proto.Reconnect reconnect = 1;
  bool has_reconnect() const;
  private:
  bool _internal_has_reconnect() const;
  public:
  void clear_reconnect();
  const ::flwr::proto::Reconnect& reconnect() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Reconnect* release_reconnect();
  ::flwr::proto::Reconnect* mutable_reconnect();
  void set_allocated_reconnect(::flwr::proto::Reconnect* reconnect);
  private:
  const ::flwr::proto::Reconnect& _internal_reconnect() const;
  ::flwr::proto::Reconnect* _internal_mutable_reconnect();
  public:
  void unsafe_arena_set_allocated_reconnect(
      ::flwr::proto::Reconnect* reconnect);
  ::flwr::proto::Reconnect* unsafe_arena_release_reconnect();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      PushTaskResResponse_ResultsEntry_DoNotUse,
      std::string, ::PROTOBUF_NAMESPACE_ID::uint32,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32> results_;
  ::flwr::proto::Reconnect* reconnect_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Run* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Run>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Run& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Run& 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(Run* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Run";
  }
  protected:
  explicit Run(::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 {
    kFabIdFieldNumber = 2,
    kFabVersionFieldNumber = 3,
    kRunIdFieldNumber = 1,
  };
  // string fab_id = 2;
  void clear_fab_id();
  const std::string& fab_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fab_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fab_id();
  PROTOBUF_MUST_USE_RESULT std::string* release_fab_id();
  void set_allocated_fab_id(std::string* fab_id);
  private:
  const std::string& _internal_fab_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fab_id(const std::string& value);
  std::string* _internal_mutable_fab_id();
  public:

  // string fab_version = 3;
  void clear_fab_version();
  const std::string& fab_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fab_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fab_version();
  PROTOBUF_MUST_USE_RESULT std::string* release_fab_version();
  void set_allocated_fab_version(std::string* fab_version);
  private:
  const std::string& _internal_fab_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fab_version(const std::string& value);
  std::string* _internal_mutable_fab_version();
  public:

  // sint64 run_id = 1;
  void clear_run_id();
  ::PROTOBUF_NAMESPACE_ID::int64 run_id() const;
  void set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_run_id() const;
  void _internal_set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fab_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fab_version_;
  ::PROTOBUF_NAMESPACE_ID::int64 run_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  GetRunRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetRunRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GetRunRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const GetRunRequest& 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(GetRunRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.GetRunRequest";
  }
  protected:
  explicit GetRunRequest(::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 {
    kRunIdFieldNumber = 1,
  };
  // sint64 run_id = 1;
  void clear_run_id();
  ::PROTOBUF_NAMESPACE_ID::int64 run_id() const;
  void set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_run_id() const;
  void _internal_set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

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

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

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

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

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

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

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

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

  GetRunResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetRunResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GetRunResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const GetRunResponse& 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(GetRunResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.GetRunResponse";
  }
  protected:
  explicit GetRunResponse(::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 {
    kRunFieldNumber = 1,
  };
  // .flwr.proto.Run run = 1;
  bool has_run() const;
  private:
  bool _internal_has_run() const;
  public:
  void clear_run();
  const ::flwr::proto::Run& run() const;
  PROTOBUF_MUST_USE_RESULT ::flwr::proto::Run* release_run();
  ::flwr::proto::Run* mutable_run();
  void set_allocated_run(::flwr::proto::Run* run);
  private:
  const ::flwr::proto::Run& _internal_run() const;
  ::flwr::proto::Run* _internal_mutable_run();
  public:
  void unsafe_arena_set_allocated_run(
      ::flwr::proto::Run* run);
  ::flwr::proto::Run* unsafe_arena_release_run();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::flwr::proto::Run* run_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  Reconnect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Reconnect>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Reconnect& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Reconnect& 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(Reconnect* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "flwr.proto.Reconnect";
  }
  protected:
  explicit Reconnect(::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 {
    kReconnectFieldNumber = 1,
  };
  // uint64 reconnect = 1;
  void clear_reconnect();
  ::PROTOBUF_NAMESPACE_ID::uint64 reconnect() const;
  void set_reconnect(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_reconnect() const;
  void _internal_set_reconnect(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint64 reconnect_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_flwr_2fproto_2ffleet_2eproto;
};
// ===================================================================


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

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

// double ping_interval = 1;
inline void CreateNodeRequest::clear_ping_interval() {
  ping_interval_ = 0;
}
inline double CreateNodeRequest::_internal_ping_interval() const {
  return ping_interval_;
}
inline double CreateNodeRequest::ping_interval() const {
  // @@protoc_insertion_point(field_get:flwr.proto.CreateNodeRequest.ping_interval)
  return _internal_ping_interval();
}
inline void CreateNodeRequest::_internal_set_ping_interval(double value) {
  
  ping_interval_ = value;
}
inline void CreateNodeRequest::set_ping_interval(double value) {
  _internal_set_ping_interval(value);
  // @@protoc_insertion_point(field_set:flwr.proto.CreateNodeRequest.ping_interval)
}

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

// CreateNodeResponse

// .flwr.proto.Node node = 1;
inline bool CreateNodeResponse::_internal_has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline bool CreateNodeResponse::has_node() const {
  return _internal_has_node();
}
inline const ::flwr::proto::Node& CreateNodeResponse::_internal_node() const {
  const ::flwr::proto::Node* p = node_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Node&>(
      ::flwr::proto::_Node_default_instance_);
}
inline const ::flwr::proto::Node& CreateNodeResponse::node() const {
  // @@protoc_insertion_point(field_get:flwr.proto.CreateNodeResponse.node)
  return _internal_node();
}
inline void CreateNodeResponse::unsafe_arena_set_allocated_node(
    ::flwr::proto::Node* node) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  node_ = node;
  if (node) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.CreateNodeResponse.node)
}
inline ::flwr::proto::Node* CreateNodeResponse::release_node() {
  
  ::flwr::proto::Node* temp = node_;
  node_ = 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::Node* CreateNodeResponse::unsafe_arena_release_node() {
  // @@protoc_insertion_point(field_release:flwr.proto.CreateNodeResponse.node)
  
  ::flwr::proto::Node* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::flwr::proto::Node* CreateNodeResponse::_internal_mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Node>(GetArenaForAllocation());
    node_ = p;
  }
  return node_;
}
inline ::flwr::proto::Node* CreateNodeResponse::mutable_node() {
  ::flwr::proto::Node* _msg = _internal_mutable_node();
  // @@protoc_insertion_point(field_mutable:flwr.proto.CreateNodeResponse.node)
  return _msg;
}
inline void CreateNodeResponse::set_allocated_node(::flwr::proto::Node* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node));
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.CreateNodeResponse.node)
}

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

// DeleteNodeRequest

// .flwr.proto.Node node = 1;
inline bool DeleteNodeRequest::_internal_has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline bool DeleteNodeRequest::has_node() const {
  return _internal_has_node();
}
inline const ::flwr::proto::Node& DeleteNodeRequest::_internal_node() const {
  const ::flwr::proto::Node* p = node_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Node&>(
      ::flwr::proto::_Node_default_instance_);
}
inline const ::flwr::proto::Node& DeleteNodeRequest::node() const {
  // @@protoc_insertion_point(field_get:flwr.proto.DeleteNodeRequest.node)
  return _internal_node();
}
inline void DeleteNodeRequest::unsafe_arena_set_allocated_node(
    ::flwr::proto::Node* node) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  node_ = node;
  if (node) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.DeleteNodeRequest.node)
}
inline ::flwr::proto::Node* DeleteNodeRequest::release_node() {
  
  ::flwr::proto::Node* temp = node_;
  node_ = 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::Node* DeleteNodeRequest::unsafe_arena_release_node() {
  // @@protoc_insertion_point(field_release:flwr.proto.DeleteNodeRequest.node)
  
  ::flwr::proto::Node* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::flwr::proto::Node* DeleteNodeRequest::_internal_mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Node>(GetArenaForAllocation());
    node_ = p;
  }
  return node_;
}
inline ::flwr::proto::Node* DeleteNodeRequest::mutable_node() {
  ::flwr::proto::Node* _msg = _internal_mutable_node();
  // @@protoc_insertion_point(field_mutable:flwr.proto.DeleteNodeRequest.node)
  return _msg;
}
inline void DeleteNodeRequest::set_allocated_node(::flwr::proto::Node* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node));
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.DeleteNodeRequest.node)
}

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

// DeleteNodeResponse

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

// PingRequest

// .flwr.proto.Node node = 1;
inline bool PingRequest::_internal_has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline bool PingRequest::has_node() const {
  return _internal_has_node();
}
inline const ::flwr::proto::Node& PingRequest::_internal_node() const {
  const ::flwr::proto::Node* p = node_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Node&>(
      ::flwr::proto::_Node_default_instance_);
}
inline const ::flwr::proto::Node& PingRequest::node() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PingRequest.node)
  return _internal_node();
}
inline void PingRequest::unsafe_arena_set_allocated_node(
    ::flwr::proto::Node* node) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  node_ = node;
  if (node) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.PingRequest.node)
}
inline ::flwr::proto::Node* PingRequest::release_node() {
  
  ::flwr::proto::Node* temp = node_;
  node_ = 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::Node* PingRequest::unsafe_arena_release_node() {
  // @@protoc_insertion_point(field_release:flwr.proto.PingRequest.node)
  
  ::flwr::proto::Node* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::flwr::proto::Node* PingRequest::_internal_mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Node>(GetArenaForAllocation());
    node_ = p;
  }
  return node_;
}
inline ::flwr::proto::Node* PingRequest::mutable_node() {
  ::flwr::proto::Node* _msg = _internal_mutable_node();
  // @@protoc_insertion_point(field_mutable:flwr.proto.PingRequest.node)
  return _msg;
}
inline void PingRequest::set_allocated_node(::flwr::proto::Node* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node));
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.PingRequest.node)
}

// double ping_interval = 2;
inline void PingRequest::clear_ping_interval() {
  ping_interval_ = 0;
}
inline double PingRequest::_internal_ping_interval() const {
  return ping_interval_;
}
inline double PingRequest::ping_interval() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PingRequest.ping_interval)
  return _internal_ping_interval();
}
inline void PingRequest::_internal_set_ping_interval(double value) {
  
  ping_interval_ = value;
}
inline void PingRequest::set_ping_interval(double value) {
  _internal_set_ping_interval(value);
  // @@protoc_insertion_point(field_set:flwr.proto.PingRequest.ping_interval)
}

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

// PingResponse

// bool success = 1;
inline void PingResponse::clear_success() {
  success_ = false;
}
inline bool PingResponse::_internal_success() const {
  return success_;
}
inline bool PingResponse::success() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PingResponse.success)
  return _internal_success();
}
inline void PingResponse::_internal_set_success(bool value) {
  
  success_ = value;
}
inline void PingResponse::set_success(bool value) {
  _internal_set_success(value);
  // @@protoc_insertion_point(field_set:flwr.proto.PingResponse.success)
}

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

// PullTaskInsRequest

// .flwr.proto.Node node = 1;
inline bool PullTaskInsRequest::_internal_has_node() const {
  return this != internal_default_instance() && node_ != nullptr;
}
inline bool PullTaskInsRequest::has_node() const {
  return _internal_has_node();
}
inline const ::flwr::proto::Node& PullTaskInsRequest::_internal_node() const {
  const ::flwr::proto::Node* p = node_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Node&>(
      ::flwr::proto::_Node_default_instance_);
}
inline const ::flwr::proto::Node& PullTaskInsRequest::node() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PullTaskInsRequest.node)
  return _internal_node();
}
inline void PullTaskInsRequest::unsafe_arena_set_allocated_node(
    ::flwr::proto::Node* node) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  node_ = node;
  if (node) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.PullTaskInsRequest.node)
}
inline ::flwr::proto::Node* PullTaskInsRequest::release_node() {
  
  ::flwr::proto::Node* temp = node_;
  node_ = 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::Node* PullTaskInsRequest::unsafe_arena_release_node() {
  // @@protoc_insertion_point(field_release:flwr.proto.PullTaskInsRequest.node)
  
  ::flwr::proto::Node* temp = node_;
  node_ = nullptr;
  return temp;
}
inline ::flwr::proto::Node* PullTaskInsRequest::_internal_mutable_node() {
  
  if (node_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Node>(GetArenaForAllocation());
    node_ = p;
  }
  return node_;
}
inline ::flwr::proto::Node* PullTaskInsRequest::mutable_node() {
  ::flwr::proto::Node* _msg = _internal_mutable_node();
  // @@protoc_insertion_point(field_mutable:flwr.proto.PullTaskInsRequest.node)
  return _msg;
}
inline void PullTaskInsRequest::set_allocated_node(::flwr::proto::Node* node) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(node_);
  }
  if (node) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(node));
    if (message_arena != submessage_arena) {
      node = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    
  } else {
    
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.PullTaskInsRequest.node)
}

// repeated string task_ids = 2;
inline int PullTaskInsRequest::_internal_task_ids_size() const {
  return task_ids_.size();
}
inline int PullTaskInsRequest::task_ids_size() const {
  return _internal_task_ids_size();
}
inline void PullTaskInsRequest::clear_task_ids() {
  task_ids_.Clear();
}
inline std::string* PullTaskInsRequest::add_task_ids() {
  std::string* _s = _internal_add_task_ids();
  // @@protoc_insertion_point(field_add_mutable:flwr.proto.PullTaskInsRequest.task_ids)
  return _s;
}
inline const std::string& PullTaskInsRequest::_internal_task_ids(int index) const {
  return task_ids_.Get(index);
}
inline const std::string& PullTaskInsRequest::task_ids(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.PullTaskInsRequest.task_ids)
  return _internal_task_ids(index);
}
inline std::string* PullTaskInsRequest::mutable_task_ids(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.PullTaskInsRequest.task_ids)
  return task_ids_.Mutable(index);
}
inline void PullTaskInsRequest::set_task_ids(int index, const std::string& value) {
  task_ids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::set_task_ids(int index, std::string&& value) {
  task_ids_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::set_task_ids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  task_ids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::set_task_ids(int index, const char* value, size_t size) {
  task_ids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:flwr.proto.PullTaskInsRequest.task_ids)
}
inline std::string* PullTaskInsRequest::_internal_add_task_ids() {
  return task_ids_.Add();
}
inline void PullTaskInsRequest::add_task_ids(const std::string& value) {
  task_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::add_task_ids(std::string&& value) {
  task_ids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::add_task_ids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  task_ids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:flwr.proto.PullTaskInsRequest.task_ids)
}
inline void PullTaskInsRequest::add_task_ids(const char* value, size_t size) {
  task_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:flwr.proto.PullTaskInsRequest.task_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PullTaskInsRequest::task_ids() const {
  // @@protoc_insertion_point(field_list:flwr.proto.PullTaskInsRequest.task_ids)
  return task_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PullTaskInsRequest::mutable_task_ids() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.PullTaskInsRequest.task_ids)
  return &task_ids_;
}

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

// PullTaskInsResponse

// .flwr.proto.Reconnect reconnect = 1;
inline bool PullTaskInsResponse::_internal_has_reconnect() const {
  return this != internal_default_instance() && reconnect_ != nullptr;
}
inline bool PullTaskInsResponse::has_reconnect() const {
  return _internal_has_reconnect();
}
inline void PullTaskInsResponse::clear_reconnect() {
  if (GetArenaForAllocation() == nullptr && reconnect_ != nullptr) {
    delete reconnect_;
  }
  reconnect_ = nullptr;
}
inline const ::flwr::proto::Reconnect& PullTaskInsResponse::_internal_reconnect() const {
  const ::flwr::proto::Reconnect* p = reconnect_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Reconnect&>(
      ::flwr::proto::_Reconnect_default_instance_);
}
inline const ::flwr::proto::Reconnect& PullTaskInsResponse::reconnect() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PullTaskInsResponse.reconnect)
  return _internal_reconnect();
}
inline void PullTaskInsResponse::unsafe_arena_set_allocated_reconnect(
    ::flwr::proto::Reconnect* reconnect) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reconnect_);
  }
  reconnect_ = reconnect;
  if (reconnect) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.PullTaskInsResponse.reconnect)
}
inline ::flwr::proto::Reconnect* PullTaskInsResponse::release_reconnect() {
  
  ::flwr::proto::Reconnect* temp = reconnect_;
  reconnect_ = 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::Reconnect* PullTaskInsResponse::unsafe_arena_release_reconnect() {
  // @@protoc_insertion_point(field_release:flwr.proto.PullTaskInsResponse.reconnect)
  
  ::flwr::proto::Reconnect* temp = reconnect_;
  reconnect_ = nullptr;
  return temp;
}
inline ::flwr::proto::Reconnect* PullTaskInsResponse::_internal_mutable_reconnect() {
  
  if (reconnect_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Reconnect>(GetArenaForAllocation());
    reconnect_ = p;
  }
  return reconnect_;
}
inline ::flwr::proto::Reconnect* PullTaskInsResponse::mutable_reconnect() {
  ::flwr::proto::Reconnect* _msg = _internal_mutable_reconnect();
  // @@protoc_insertion_point(field_mutable:flwr.proto.PullTaskInsResponse.reconnect)
  return _msg;
}
inline void PullTaskInsResponse::set_allocated_reconnect(::flwr::proto::Reconnect* reconnect) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reconnect_;
  }
  if (reconnect) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Reconnect>::GetOwningArena(reconnect);
    if (message_arena != submessage_arena) {
      reconnect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reconnect, submessage_arena);
    }
    
  } else {
    
  }
  reconnect_ = reconnect;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.PullTaskInsResponse.reconnect)
}

// repeated .flwr.proto.TaskIns task_ins_list = 2;
inline int PullTaskInsResponse::_internal_task_ins_list_size() const {
  return task_ins_list_.size();
}
inline int PullTaskInsResponse::task_ins_list_size() const {
  return _internal_task_ins_list_size();
}
inline ::flwr::proto::TaskIns* PullTaskInsResponse::mutable_task_ins_list(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.PullTaskInsResponse.task_ins_list)
  return task_ins_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskIns >*
PullTaskInsResponse::mutable_task_ins_list() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.PullTaskInsResponse.task_ins_list)
  return &task_ins_list_;
}
inline const ::flwr::proto::TaskIns& PullTaskInsResponse::_internal_task_ins_list(int index) const {
  return task_ins_list_.Get(index);
}
inline const ::flwr::proto::TaskIns& PullTaskInsResponse::task_ins_list(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.PullTaskInsResponse.task_ins_list)
  return _internal_task_ins_list(index);
}
inline ::flwr::proto::TaskIns* PullTaskInsResponse::_internal_add_task_ins_list() {
  return task_ins_list_.Add();
}
inline ::flwr::proto::TaskIns* PullTaskInsResponse::add_task_ins_list() {
  ::flwr::proto::TaskIns* _add = _internal_add_task_ins_list();
  // @@protoc_insertion_point(field_add:flwr.proto.PullTaskInsResponse.task_ins_list)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskIns >&
PullTaskInsResponse::task_ins_list() const {
  // @@protoc_insertion_point(field_list:flwr.proto.PullTaskInsResponse.task_ins_list)
  return task_ins_list_;
}

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

// PushTaskResRequest

// repeated .flwr.proto.TaskRes task_res_list = 1;
inline int PushTaskResRequest::_internal_task_res_list_size() const {
  return task_res_list_.size();
}
inline int PushTaskResRequest::task_res_list_size() const {
  return _internal_task_res_list_size();
}
inline ::flwr::proto::TaskRes* PushTaskResRequest::mutable_task_res_list(int index) {
  // @@protoc_insertion_point(field_mutable:flwr.proto.PushTaskResRequest.task_res_list)
  return task_res_list_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskRes >*
PushTaskResRequest::mutable_task_res_list() {
  // @@protoc_insertion_point(field_mutable_list:flwr.proto.PushTaskResRequest.task_res_list)
  return &task_res_list_;
}
inline const ::flwr::proto::TaskRes& PushTaskResRequest::_internal_task_res_list(int index) const {
  return task_res_list_.Get(index);
}
inline const ::flwr::proto::TaskRes& PushTaskResRequest::task_res_list(int index) const {
  // @@protoc_insertion_point(field_get:flwr.proto.PushTaskResRequest.task_res_list)
  return _internal_task_res_list(index);
}
inline ::flwr::proto::TaskRes* PushTaskResRequest::_internal_add_task_res_list() {
  return task_res_list_.Add();
}
inline ::flwr::proto::TaskRes* PushTaskResRequest::add_task_res_list() {
  ::flwr::proto::TaskRes* _add = _internal_add_task_res_list();
  // @@protoc_insertion_point(field_add:flwr.proto.PushTaskResRequest.task_res_list)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::flwr::proto::TaskRes >&
PushTaskResRequest::task_res_list() const {
  // @@protoc_insertion_point(field_list:flwr.proto.PushTaskResRequest.task_res_list)
  return task_res_list_;
}

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

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

// PushTaskResResponse

// .flwr.proto.Reconnect reconnect = 1;
inline bool PushTaskResResponse::_internal_has_reconnect() const {
  return this != internal_default_instance() && reconnect_ != nullptr;
}
inline bool PushTaskResResponse::has_reconnect() const {
  return _internal_has_reconnect();
}
inline void PushTaskResResponse::clear_reconnect() {
  if (GetArenaForAllocation() == nullptr && reconnect_ != nullptr) {
    delete reconnect_;
  }
  reconnect_ = nullptr;
}
inline const ::flwr::proto::Reconnect& PushTaskResResponse::_internal_reconnect() const {
  const ::flwr::proto::Reconnect* p = reconnect_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Reconnect&>(
      ::flwr::proto::_Reconnect_default_instance_);
}
inline const ::flwr::proto::Reconnect& PushTaskResResponse::reconnect() const {
  // @@protoc_insertion_point(field_get:flwr.proto.PushTaskResResponse.reconnect)
  return _internal_reconnect();
}
inline void PushTaskResResponse::unsafe_arena_set_allocated_reconnect(
    ::flwr::proto::Reconnect* reconnect) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(reconnect_);
  }
  reconnect_ = reconnect;
  if (reconnect) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.PushTaskResResponse.reconnect)
}
inline ::flwr::proto::Reconnect* PushTaskResResponse::release_reconnect() {
  
  ::flwr::proto::Reconnect* temp = reconnect_;
  reconnect_ = 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::Reconnect* PushTaskResResponse::unsafe_arena_release_reconnect() {
  // @@protoc_insertion_point(field_release:flwr.proto.PushTaskResResponse.reconnect)
  
  ::flwr::proto::Reconnect* temp = reconnect_;
  reconnect_ = nullptr;
  return temp;
}
inline ::flwr::proto::Reconnect* PushTaskResResponse::_internal_mutable_reconnect() {
  
  if (reconnect_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Reconnect>(GetArenaForAllocation());
    reconnect_ = p;
  }
  return reconnect_;
}
inline ::flwr::proto::Reconnect* PushTaskResResponse::mutable_reconnect() {
  ::flwr::proto::Reconnect* _msg = _internal_mutable_reconnect();
  // @@protoc_insertion_point(field_mutable:flwr.proto.PushTaskResResponse.reconnect)
  return _msg;
}
inline void PushTaskResResponse::set_allocated_reconnect(::flwr::proto::Reconnect* reconnect) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reconnect_;
  }
  if (reconnect) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Reconnect>::GetOwningArena(reconnect);
    if (message_arena != submessage_arena) {
      reconnect = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reconnect, submessage_arena);
    }
    
  } else {
    
  }
  reconnect_ = reconnect;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.PushTaskResResponse.reconnect)
}

// map<string, uint32> results = 2;
inline int PushTaskResResponse::_internal_results_size() const {
  return results_.size();
}
inline int PushTaskResResponse::results_size() const {
  return _internal_results_size();
}
inline void PushTaskResResponse::clear_results() {
  results_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >&
PushTaskResResponse::_internal_results() const {
  return results_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >&
PushTaskResResponse::results() const {
  // @@protoc_insertion_point(field_map:flwr.proto.PushTaskResResponse.results)
  return _internal_results();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >*
PushTaskResResponse::_internal_mutable_results() {
  return results_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::uint32 >*
PushTaskResResponse::mutable_results() {
  // @@protoc_insertion_point(field_mutable_map:flwr.proto.PushTaskResResponse.results)
  return _internal_mutable_results();
}

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

// Run

// sint64 run_id = 1;
inline void Run::clear_run_id() {
  run_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Run::_internal_run_id() const {
  return run_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Run::run_id() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Run.run_id)
  return _internal_run_id();
}
inline void Run::_internal_set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  run_id_ = value;
}
inline void Run::set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_run_id(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Run.run_id)
}

// string fab_id = 2;
inline void Run::clear_fab_id() {
  fab_id_.ClearToEmpty();
}
inline const std::string& Run::fab_id() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Run.fab_id)
  return _internal_fab_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Run::set_fab_id(ArgT0&& arg0, ArgT... args) {
 
 fab_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Run.fab_id)
}
inline std::string* Run::mutable_fab_id() {
  std::string* _s = _internal_mutable_fab_id();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Run.fab_id)
  return _s;
}
inline const std::string& Run::_internal_fab_id() const {
  return fab_id_.Get();
}
inline void Run::_internal_set_fab_id(const std::string& value) {
  
  fab_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Run::_internal_mutable_fab_id() {
  
  return fab_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Run::release_fab_id() {
  // @@protoc_insertion_point(field_release:flwr.proto.Run.fab_id)
  return fab_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Run::set_allocated_fab_id(std::string* fab_id) {
  if (fab_id != nullptr) {
    
  } else {
    
  }
  fab_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fab_id,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Run.fab_id)
}

// string fab_version = 3;
inline void Run::clear_fab_version() {
  fab_version_.ClearToEmpty();
}
inline const std::string& Run::fab_version() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Run.fab_version)
  return _internal_fab_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Run::set_fab_version(ArgT0&& arg0, ArgT... args) {
 
 fab_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:flwr.proto.Run.fab_version)
}
inline std::string* Run::mutable_fab_version() {
  std::string* _s = _internal_mutable_fab_version();
  // @@protoc_insertion_point(field_mutable:flwr.proto.Run.fab_version)
  return _s;
}
inline const std::string& Run::_internal_fab_version() const {
  return fab_version_.Get();
}
inline void Run::_internal_set_fab_version(const std::string& value) {
  
  fab_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* Run::_internal_mutable_fab_version() {
  
  return fab_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* Run::release_fab_version() {
  // @@protoc_insertion_point(field_release:flwr.proto.Run.fab_version)
  return fab_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void Run::set_allocated_fab_version(std::string* fab_version) {
  if (fab_version != nullptr) {
    
  } else {
    
  }
  fab_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fab_version,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.Run.fab_version)
}

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

// GetRunRequest

// sint64 run_id = 1;
inline void GetRunRequest::clear_run_id() {
  run_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GetRunRequest::_internal_run_id() const {
  return run_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GetRunRequest::run_id() const {
  // @@protoc_insertion_point(field_get:flwr.proto.GetRunRequest.run_id)
  return _internal_run_id();
}
inline void GetRunRequest::_internal_set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  run_id_ = value;
}
inline void GetRunRequest::set_run_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_run_id(value);
  // @@protoc_insertion_point(field_set:flwr.proto.GetRunRequest.run_id)
}

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

// GetRunResponse

// .flwr.proto.Run run = 1;
inline bool GetRunResponse::_internal_has_run() const {
  return this != internal_default_instance() && run_ != nullptr;
}
inline bool GetRunResponse::has_run() const {
  return _internal_has_run();
}
inline void GetRunResponse::clear_run() {
  if (GetArenaForAllocation() == nullptr && run_ != nullptr) {
    delete run_;
  }
  run_ = nullptr;
}
inline const ::flwr::proto::Run& GetRunResponse::_internal_run() const {
  const ::flwr::proto::Run* p = run_;
  return p != nullptr ? *p : reinterpret_cast<const ::flwr::proto::Run&>(
      ::flwr::proto::_Run_default_instance_);
}
inline const ::flwr::proto::Run& GetRunResponse::run() const {
  // @@protoc_insertion_point(field_get:flwr.proto.GetRunResponse.run)
  return _internal_run();
}
inline void GetRunResponse::unsafe_arena_set_allocated_run(
    ::flwr::proto::Run* run) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(run_);
  }
  run_ = run;
  if (run) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:flwr.proto.GetRunResponse.run)
}
inline ::flwr::proto::Run* GetRunResponse::release_run() {
  
  ::flwr::proto::Run* temp = run_;
  run_ = 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::Run* GetRunResponse::unsafe_arena_release_run() {
  // @@protoc_insertion_point(field_release:flwr.proto.GetRunResponse.run)
  
  ::flwr::proto::Run* temp = run_;
  run_ = nullptr;
  return temp;
}
inline ::flwr::proto::Run* GetRunResponse::_internal_mutable_run() {
  
  if (run_ == nullptr) {
    auto* p = CreateMaybeMessage<::flwr::proto::Run>(GetArenaForAllocation());
    run_ = p;
  }
  return run_;
}
inline ::flwr::proto::Run* GetRunResponse::mutable_run() {
  ::flwr::proto::Run* _msg = _internal_mutable_run();
  // @@protoc_insertion_point(field_mutable:flwr.proto.GetRunResponse.run)
  return _msg;
}
inline void GetRunResponse::set_allocated_run(::flwr::proto::Run* run) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete run_;
  }
  if (run) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::flwr::proto::Run>::GetOwningArena(run);
    if (message_arena != submessage_arena) {
      run = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, run, submessage_arena);
    }
    
  } else {
    
  }
  run_ = run;
  // @@protoc_insertion_point(field_set_allocated:flwr.proto.GetRunResponse.run)
}

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

// Reconnect

// uint64 reconnect = 1;
inline void Reconnect::clear_reconnect() {
  reconnect_ = uint64_t{0u};
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Reconnect::_internal_reconnect() const {
  return reconnect_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Reconnect::reconnect() const {
  // @@protoc_insertion_point(field_get:flwr.proto.Reconnect.reconnect)
  return _internal_reconnect();
}
inline void Reconnect::_internal_set_reconnect(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  reconnect_ = value;
}
inline void Reconnect::set_reconnect(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_reconnect(value);
  // @@protoc_insertion_point(field_set:flwr.proto.Reconnect.reconnect)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace flwr

// @@protoc_insertion_point(global_scope)

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