// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: hillab_beam_stabilization_system.proto
// Protobuf C++ Version: 4.25.1

#ifndef GOOGLE_PROTOBUF_INCLUDED_hillab_5fbeam_5fstabilization_5fsystem_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_hillab_5fbeam_5fstabilization_5fsystem_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4025000
#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  // PROTOBUF_VERSION

#if 4025001 < 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  // PROTOBUF_MIN_PROTOC_VERSION
#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_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
#include "google/protobuf/empty.pb.h"
#include "google/protobuf/timestamp.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_hillab_5fbeam_5fstabilization_5fsystem_2eproto

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto {
  static const ::uint32_t offsets[];
};
namespace hillab {
namespace v4 {
class AppInfoResponse;
struct AppInfoResponseDefaultTypeInternal;
extern AppInfoResponseDefaultTypeInternal _AppInfoResponse_default_instance_;
class BeamProfile;
struct BeamProfileDefaultTypeInternal;
extern BeamProfileDefaultTypeInternal _BeamProfile_default_instance_;
class BeamProfileStream;
struct BeamProfileStreamDefaultTypeInternal;
extern BeamProfileStreamDefaultTypeInternal _BeamProfileStream_default_instance_;
class GetRequest;
struct GetRequestDefaultTypeInternal;
extern GetRequestDefaultTypeInternal _GetRequest_default_instance_;
class GetResponse;
struct GetResponseDefaultTypeInternal;
extern GetResponseDefaultTypeInternal _GetResponse_default_instance_;
class ImageStreamServerRequest;
struct ImageStreamServerRequestDefaultTypeInternal;
extern ImageStreamServerRequestDefaultTypeInternal _ImageStreamServerRequest_default_instance_;
class ImageStreamServerResponse;
struct ImageStreamServerResponseDefaultTypeInternal;
extern ImageStreamServerResponseDefaultTypeInternal _ImageStreamServerResponse_default_instance_;
class PresetListResponse;
struct PresetListResponseDefaultTypeInternal;
extern PresetListResponseDefaultTypeInternal _PresetListResponse_default_instance_;
class PresetRequest;
struct PresetRequestDefaultTypeInternal;
extern PresetRequestDefaultTypeInternal _PresetRequest_default_instance_;
class PresetResponse;
struct PresetResponseDefaultTypeInternal;
extern PresetResponseDefaultTypeInternal _PresetResponse_default_instance_;
class SetRequest;
struct SetRequestDefaultTypeInternal;
extern SetRequestDefaultTypeInternal _SetRequest_default_instance_;
class SystemLogStream;
struct SystemLogStreamDefaultTypeInternal;
extern SystemLogStreamDefaultTypeInternal _SystemLogStream_default_instance_;
class Value;
struct ValueDefaultTypeInternal;
extern ValueDefaultTypeInternal _Value_default_instance_;
}  // namespace v4
}  // namespace hillab
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace hillab {
namespace v4 {
enum SystemLogType : int {
  SYSTEMLOGTYPE_INFO = 0,
  SYSTEMLOGTYPE_ERROR = 1,
  SystemLogType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  SystemLogType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool SystemLogType_IsValid(int value);
extern const uint32_t SystemLogType_internal_data_[];
constexpr SystemLogType SystemLogType_MIN = static_cast<SystemLogType>(0);
constexpr SystemLogType SystemLogType_MAX = static_cast<SystemLogType>(1);
constexpr int SystemLogType_ARRAYSIZE = 1 + 1;
const std::string& SystemLogType_Name(SystemLogType value);
template <typename T>
const std::string& SystemLogType_Name(T value) {
  static_assert(std::is_same<T, SystemLogType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SystemLogType_Name().");
  return SystemLogType_Name(static_cast<SystemLogType>(value));
}
const std::string& SystemLogType_Name(SystemLogType value);
bool SystemLogType_Parse(absl::string_view name, SystemLogType* value);

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


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

class Value final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.Value) */ {
 public:
  inline Value() : Value(nullptr) {}
  ~Value() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR Value(::google::protobuf::internal::ConstantInitialized);

  inline Value(const Value& from)
      : Value(nullptr, from) {}
  Value(Value&& from) noexcept
    : Value() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Value& default_instance() {
    return *internal_default_instance();
  }
  enum ValueCase {
    kBoolValue = 1,
    kIntValue = 2,
    kFloatValue = 3,
    kStringValue = 4,
    VALUE_NOT_SET = 0,
  };

  static inline const Value* internal_default_instance() {
    return reinterpret_cast<const Value*>(
               &_Value_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Value& a, Value& b) {
    a.Swap(&b);
  }
  inline void Swap(Value* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Value* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  Value* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Value>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const Value& from);
  void MergeFrom(const Value& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Value* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.Value";
  }
  protected:
  explicit Value(::google::protobuf::Arena* arena);
  Value(::google::protobuf::Arena* arena, const Value& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kBoolValueFieldNumber = 1,
    kIntValueFieldNumber = 2,
    kFloatValueFieldNumber = 3,
    kStringValueFieldNumber = 4,
  };
  // bool bool_value = 1;
  bool has_bool_value() const;
  void clear_bool_value() ;
  bool bool_value() const;
  void set_bool_value(bool value);

  private:
  bool _internal_bool_value() const;
  void _internal_set_bool_value(bool value);

  public:
  // int32 int_value = 2;
  bool has_int_value() const;
  void clear_int_value() ;
  ::int32_t int_value() const;
  void set_int_value(::int32_t value);

  private:
  ::int32_t _internal_int_value() const;
  void _internal_set_int_value(::int32_t value);

  public:
  // float float_value = 3;
  bool has_float_value() const;
  void clear_float_value() ;
  float float_value() const;
  void set_float_value(float value);

  private:
  float _internal_float_value() const;
  void _internal_set_float_value(float value);

  public:
  // string string_value = 4;
  bool has_string_value() const;
  void clear_string_value() ;
  const std::string& string_value() const;
  void set_string_value(const char* str);
  std::string* mutable_string_value();
  PROTOBUF_NODISCARD std::string* release_string_value();
  void set_allocated_string_value(std::string* value);

  private:
  const std::string& _internal_string_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(
      const std::string& value);
  std::string* _internal_mutable_string_value();

  public:
  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:hillab.v4.Value)
 private:
  class _Internal;
  void set_has_bool_value();
  void set_has_int_value();
  void set_has_float_value();
  void set_has_string_value();

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

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 4, 0,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    union ValueUnion {
      constexpr ValueUnion() : _constinit_{} {}
        ::google::protobuf::internal::ConstantInitialized _constinit_;
      bool bool_value_;
      ::int32_t int_value_;
      float float_value_;
      ::google::protobuf::internal::ArenaStringPtr string_value_;
    } value_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class PresetResponse final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.PresetResponse) */ {
 public:
  inline PresetResponse() : PresetResponse(nullptr) {}
  ~PresetResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PresetResponse(::google::protobuf::internal::ConstantInitialized);

  inline PresetResponse(const PresetResponse& from)
      : PresetResponse(nullptr, from) {}
  PresetResponse(PresetResponse&& from) noexcept
    : PresetResponse() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PresetResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const PresetResponse* internal_default_instance() {
    return reinterpret_cast<const PresetResponse*>(
               &_PresetResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(PresetResponse& a, PresetResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PresetResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PresetResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  PresetResponse* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PresetResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const PresetResponse& from);
  void MergeFrom(const PresetResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PresetResponse* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.PresetResponse";
  }
  protected:
  explicit PresetResponse(::google::protobuf::Arena* arena);
  PresetResponse(::google::protobuf::Arena* arena, const PresetResponse& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.PresetResponse)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class PresetRequest final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.PresetRequest) */ {
 public:
  inline PresetRequest() : PresetRequest(nullptr) {}
  ~PresetRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PresetRequest(::google::protobuf::internal::ConstantInitialized);

  inline PresetRequest(const PresetRequest& from)
      : PresetRequest(nullptr, from) {}
  PresetRequest(PresetRequest&& from) noexcept
    : PresetRequest() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

  friend void swap(PresetRequest& a, PresetRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(PresetRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PresetRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  PresetRequest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PresetRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const PresetRequest& from);
  void MergeFrom(const PresetRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PresetRequest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.PresetRequest";
  }
  protected:
  explicit PresetRequest(::google::protobuf::Arena* arena);
  PresetRequest(::google::protobuf::Arena* arena, const PresetRequest& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
  };
  // string name = 1;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.PresetRequest)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      36, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class PresetListResponse final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.PresetListResponse) */ {
 public:
  inline PresetListResponse() : PresetListResponse(nullptr) {}
  ~PresetListResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR PresetListResponse(::google::protobuf::internal::ConstantInitialized);

  inline PresetListResponse(const PresetListResponse& from)
      : PresetListResponse(nullptr, from) {}
  PresetListResponse(PresetListResponse&& from) noexcept
    : PresetListResponse() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const PresetListResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const PresetListResponse* internal_default_instance() {
    return reinterpret_cast<const PresetListResponse*>(
               &_PresetListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(PresetListResponse& a, PresetListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(PresetListResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PresetListResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  PresetListResponse* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PresetListResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const PresetListResponse& from);
  void MergeFrom(const PresetListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(PresetListResponse* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.PresetListResponse";
  }
  protected:
  explicit PresetListResponse(::google::protobuf::Arena* arena);
  PresetListResponse(::google::protobuf::Arena* arena, const PresetListResponse& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameListFieldNumber = 1,
  };
  // repeated string name_list = 1;
  int name_list_size() const;
  private:
  int _internal_name_list_size() const;

  public:
  void clear_name_list() ;
  const std::string& name_list(int index) const;
  std::string* mutable_name_list(int index);
  void set_name_list(int index, const std::string& value);
  void set_name_list(int index, std::string&& value);
  void set_name_list(int index, const char* value);
  void set_name_list(int index, const char* value, std::size_t size);
  void set_name_list(int index, absl::string_view value);
  std::string* add_name_list();
  void add_name_list(const std::string& value);
  void add_name_list(std::string&& value);
  void add_name_list(const char* value);
  void add_name_list(const char* value, std::size_t size);
  void add_name_list(absl::string_view value);
  const ::google::protobuf::RepeatedPtrField<std::string>& name_list() const;
  ::google::protobuf::RepeatedPtrField<std::string>* mutable_name_list();

  private:
  const ::google::protobuf::RepeatedPtrField<std::string>& _internal_name_list() const;
  ::google::protobuf::RepeatedPtrField<std::string>* _internal_mutable_name_list();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.PresetListResponse)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      46, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField<std::string> name_list_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class ImageStreamServerResponse final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.ImageStreamServerResponse) */ {
 public:
  inline ImageStreamServerResponse() : ImageStreamServerResponse(nullptr) {}
  ~ImageStreamServerResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ImageStreamServerResponse(::google::protobuf::internal::ConstantInitialized);

  inline ImageStreamServerResponse(const ImageStreamServerResponse& from)
      : ImageStreamServerResponse(nullptr, from) {}
  ImageStreamServerResponse(ImageStreamServerResponse&& from) noexcept
    : ImageStreamServerResponse() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

  friend void swap(ImageStreamServerResponse& a, ImageStreamServerResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageStreamServerResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ImageStreamServerResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ImageStreamServerResponse* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageStreamServerResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const ImageStreamServerResponse& from);
  void MergeFrom(const ImageStreamServerResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ImageStreamServerResponse* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.ImageStreamServerResponse";
  }
  protected:
  explicit ImageStreamServerResponse(::google::protobuf::Arena* arena);
  ImageStreamServerResponse(::google::protobuf::Arena* arena, const ImageStreamServerResponse& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kIpFieldNumber = 1,
    kSdpFieldNumber = 7,
    kPortFieldNumber = 2,
    kMtuFieldNumber = 3,
    kDownscaleFieldNumber = 4,
    kRunningFieldNumber = 5,
    kAutoRunningFieldNumber = 6,
  };
  // string ip = 1;
  void clear_ip() ;
  const std::string& ip() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_ip(Arg_&& arg, Args_... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* value);

  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(
      const std::string& value);
  std::string* _internal_mutable_ip();

  public:
  // string sdp = 7;
  void clear_sdp() ;
  const std::string& sdp() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_sdp(Arg_&& arg, Args_... args);
  std::string* mutable_sdp();
  PROTOBUF_NODISCARD std::string* release_sdp();
  void set_allocated_sdp(std::string* value);

  private:
  const std::string& _internal_sdp() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdp(
      const std::string& value);
  std::string* _internal_mutable_sdp();

  public:
  // int32 port = 2;
  void clear_port() ;
  ::int32_t port() const;
  void set_port(::int32_t value);

  private:
  ::int32_t _internal_port() const;
  void _internal_set_port(::int32_t value);

  public:
  // int32 mtu = 3;
  void clear_mtu() ;
  ::int32_t mtu() const;
  void set_mtu(::int32_t value);

  private:
  ::int32_t _internal_mtu() const;
  void _internal_set_mtu(::int32_t value);

  public:
  // int32 downscale = 4;
  void clear_downscale() ;
  ::int32_t downscale() const;
  void set_downscale(::int32_t value);

  private:
  ::int32_t _internal_downscale() const;
  void _internal_set_downscale(::int32_t value);

  public:
  // bool running = 5;
  void clear_running() ;
  bool running() const;
  void set_running(bool value);

  private:
  bool _internal_running() const;
  void _internal_set_running(bool value);

  public:
  // bool auto_running = 6;
  void clear_auto_running() ;
  bool auto_running() const;
  void set_auto_running(bool value);

  private:
  bool _internal_auto_running() const;
  void _internal_set_auto_running(bool value);

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.ImageStreamServerResponse)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 7, 0,
      49, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr ip_;
    ::google::protobuf::internal::ArenaStringPtr sdp_;
    ::int32_t port_;
    ::int32_t mtu_;
    ::int32_t downscale_;
    bool running_;
    bool auto_running_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class ImageStreamServerRequest final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.ImageStreamServerRequest) */ {
 public:
  inline ImageStreamServerRequest() : ImageStreamServerRequest(nullptr) {}
  ~ImageStreamServerRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR ImageStreamServerRequest(::google::protobuf::internal::ConstantInitialized);

  inline ImageStreamServerRequest(const ImageStreamServerRequest& from)
      : ImageStreamServerRequest(nullptr, from) {}
  ImageStreamServerRequest(ImageStreamServerRequest&& from) noexcept
    : ImageStreamServerRequest() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ImageStreamServerRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const ImageStreamServerRequest* internal_default_instance() {
    return reinterpret_cast<const ImageStreamServerRequest*>(
               &_ImageStreamServerRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(ImageStreamServerRequest& a, ImageStreamServerRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(ImageStreamServerRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ImageStreamServerRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  ImageStreamServerRequest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ImageStreamServerRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const ImageStreamServerRequest& from);
  void MergeFrom(const ImageStreamServerRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(ImageStreamServerRequest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.ImageStreamServerRequest";
  }
  protected:
  explicit ImageStreamServerRequest(::google::protobuf::Arena* arena);
  ImageStreamServerRequest(::google::protobuf::Arena* arena, const ImageStreamServerRequest& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMtuFieldNumber = 2,
    kRunningFieldNumber = 1,
    kAutoRunningFieldNumber = 4,
    kDownscaleFieldNumber = 3,
  };
  // optional int32 mtu = 2;
  bool has_mtu() const;
  void clear_mtu() ;
  ::int32_t mtu() const;
  void set_mtu(::int32_t value);

  private:
  ::int32_t _internal_mtu() const;
  void _internal_set_mtu(::int32_t value);

  public:
  // optional bool running = 1;
  bool has_running() const;
  void clear_running() ;
  bool running() const;
  void set_running(bool value);

  private:
  bool _internal_running() const;
  void _internal_set_running(bool value);

  public:
  // optional bool auto_running = 4;
  bool has_auto_running() const;
  void clear_auto_running() ;
  bool auto_running() const;
  void set_auto_running(bool value);

  private:
  bool _internal_auto_running() const;
  void _internal_set_auto_running(bool value);

  public:
  // optional int32 downscale = 3;
  bool has_downscale() const;
  void clear_downscale() ;
  ::int32_t downscale() const;
  void set_downscale(::int32_t value);

  private:
  ::int32_t _internal_downscale() const;
  void _internal_set_downscale(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.ImageStreamServerRequest)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::int32_t mtu_;
    bool running_;
    bool auto_running_;
    ::int32_t downscale_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class GetRequest final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.GetRequest) */ {
 public:
  inline GetRequest() : GetRequest(nullptr) {}
  ~GetRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetRequest(::google::protobuf::internal::ConstantInitialized);

  inline GetRequest(const GetRequest& from)
      : GetRequest(nullptr, from) {}
  GetRequest(GetRequest&& from) noexcept
    : GetRequest() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetRequest* internal_default_instance() {
    return reinterpret_cast<const GetRequest*>(
               &_GetRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(GetRequest& a, GetRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(GetRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  GetRequest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const GetRequest& from);
  void MergeFrom(const GetRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GetRequest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.GetRequest";
  }
  protected:
  explicit GetRequest(::google::protobuf::Arena* arena);
  GetRequest(::google::protobuf::Arena* arena, const GetRequest& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kKeyFieldNumber = 1,
  };
  // string key = 1;
  void clear_key() ;
  const std::string& key() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* value);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.GetRequest)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      32, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr key_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class BeamProfile final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.BeamProfile) */ {
 public:
  inline BeamProfile() : BeamProfile(nullptr) {}
  ~BeamProfile() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BeamProfile(::google::protobuf::internal::ConstantInitialized);

  inline BeamProfile(const BeamProfile& from)
      : BeamProfile(nullptr, from) {}
  BeamProfile(BeamProfile&& from) noexcept
    : BeamProfile() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const BeamProfile& default_instance() {
    return *internal_default_instance();
  }
  static inline const BeamProfile* internal_default_instance() {
    return reinterpret_cast<const BeamProfile*>(
               &_BeamProfile_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(BeamProfile& a, BeamProfile& b) {
    a.Swap(&b);
  }
  inline void Swap(BeamProfile* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BeamProfile* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  BeamProfile* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BeamProfile>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const BeamProfile& from);
  void MergeFrom(const BeamProfile& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(BeamProfile* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.BeamProfile";
  }
  protected:
  explicit BeamProfile(::google::protobuf::Arena* arena);
  BeamProfile(::google::protobuf::Arena* arena, const BeamProfile& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kLatestValueFieldNumber = 2,
    kAverageFieldNumber = 3,
    kStandardDeviationFieldNumber = 4,
    kIndexFieldNumber = 1,
  };
  // double latest_value = 2;
  void clear_latest_value() ;
  double latest_value() const;
  void set_latest_value(double value);

  private:
  double _internal_latest_value() const;
  void _internal_set_latest_value(double value);

  public:
  // double average = 3;
  void clear_average() ;
  double average() const;
  void set_average(double value);

  private:
  double _internal_average() const;
  void _internal_set_average(double value);

  public:
  // double standard_deviation = 4;
  void clear_standard_deviation() ;
  double standard_deviation() const;
  void set_standard_deviation(double value);

  private:
  double _internal_standard_deviation() const;
  void _internal_set_standard_deviation(double value);

  public:
  // int32 index = 1;
  void clear_index() ;
  ::int32_t index() const;
  void set_index(::int32_t value);

  private:
  ::int32_t _internal_index() const;
  void _internal_set_index(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.BeamProfile)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 4, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    double latest_value_;
    double average_;
    double standard_deviation_;
    ::int32_t index_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class AppInfoResponse final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.AppInfoResponse) */ {
 public:
  inline AppInfoResponse() : AppInfoResponse(nullptr) {}
  ~AppInfoResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR AppInfoResponse(::google::protobuf::internal::ConstantInitialized);

  inline AppInfoResponse(const AppInfoResponse& from)
      : AppInfoResponse(nullptr, from) {}
  AppInfoResponse(AppInfoResponse&& from) noexcept
    : AppInfoResponse() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

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

  friend void swap(AppInfoResponse& a, AppInfoResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(AppInfoResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AppInfoResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  AppInfoResponse* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AppInfoResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const AppInfoResponse& from);
  void MergeFrom(const AppInfoResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(AppInfoResponse* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.AppInfoResponse";
  }
  protected:
  explicit AppInfoResponse(::google::protobuf::Arena* arena);
  AppInfoResponse(::google::protobuf::Arena* arena, const AppInfoResponse& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kVersionFieldNumber = 1,
  };
  // string version = 1;
  void clear_version() ;
  const std::string& version() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_version(Arg_&& arg, Args_... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* value);

  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(
      const std::string& value);
  std::string* _internal_mutable_version();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.AppInfoResponse)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr version_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class SystemLogStream final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.SystemLogStream) */ {
 public:
  inline SystemLogStream() : SystemLogStream(nullptr) {}
  ~SystemLogStream() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SystemLogStream(::google::protobuf::internal::ConstantInitialized);

  inline SystemLogStream(const SystemLogStream& from)
      : SystemLogStream(nullptr, from) {}
  SystemLogStream(SystemLogStream&& from) noexcept
    : SystemLogStream() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SystemLogStream& default_instance() {
    return *internal_default_instance();
  }
  static inline const SystemLogStream* internal_default_instance() {
    return reinterpret_cast<const SystemLogStream*>(
               &_SystemLogStream_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(SystemLogStream& a, SystemLogStream& b) {
    a.Swap(&b);
  }
  inline void Swap(SystemLogStream* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SystemLogStream* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  SystemLogStream* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SystemLogStream>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const SystemLogStream& from);
  void MergeFrom(const SystemLogStream& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SystemLogStream* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.SystemLogStream";
  }
  protected:
  explicit SystemLogStream(::google::protobuf::Arena* arena);
  SystemLogStream(::google::protobuf::Arena* arena, const SystemLogStream& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMessageFieldNumber = 3,
    kTimeFieldNumber = 1,
    kTypeFieldNumber = 2,
  };
  // string message = 3;
  void clear_message() ;
  const std::string& message() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_message(Arg_&& arg, Args_... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* value);

  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(
      const std::string& value);
  std::string* _internal_mutable_message();

  public:
  // .google.protobuf.Timestamp time = 1;
  bool has_time() const;
  void clear_time() ;
  const ::google::protobuf::Timestamp& time() const;
  PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_time();
  ::google::protobuf::Timestamp* mutable_time();
  void set_allocated_time(::google::protobuf::Timestamp* value);
  void unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value);
  ::google::protobuf::Timestamp* unsafe_arena_release_time();

  private:
  const ::google::protobuf::Timestamp& _internal_time() const;
  ::google::protobuf::Timestamp* _internal_mutable_time();

  public:
  // .hillab.v4.SystemLogType type = 2;
  void clear_type() ;
  ::hillab::v4::SystemLogType type() const;
  void set_type(::hillab::v4::SystemLogType value);

  private:
  ::hillab::v4::SystemLogType _internal_type() const;
  void _internal_set_type(::hillab::v4::SystemLogType value);

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.SystemLogStream)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 1,
      41, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr message_;
    ::google::protobuf::Timestamp* time_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class SetRequest final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.SetRequest) */ {
 public:
  inline SetRequest() : SetRequest(nullptr) {}
  ~SetRequest() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR SetRequest(::google::protobuf::internal::ConstantInitialized);

  inline SetRequest(const SetRequest& from)
      : SetRequest(nullptr, from) {}
  SetRequest(SetRequest&& from) noexcept
    : SetRequest() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const SetRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const SetRequest* internal_default_instance() {
    return reinterpret_cast<const SetRequest*>(
               &_SetRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(SetRequest& a, SetRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SetRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SetRequest* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  SetRequest* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SetRequest>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const SetRequest& from);
  void MergeFrom(const SetRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(SetRequest* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.SetRequest";
  }
  protected:
  explicit SetRequest(::google::protobuf::Arena* arena);
  SetRequest(::google::protobuf::Arena* arena, const SetRequest& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key() ;
  const std::string& key() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* value);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // .hillab.v4.Value value = 2;
  bool has_value() const;
  void clear_value() ;
  const ::hillab::v4::Value& value() const;
  PROTOBUF_NODISCARD ::hillab::v4::Value* release_value();
  ::hillab::v4::Value* mutable_value();
  void set_allocated_value(::hillab::v4::Value* value);
  void unsafe_arena_set_allocated_value(::hillab::v4::Value* value);
  ::hillab::v4::Value* unsafe_arena_release_value();

  private:
  const ::hillab::v4::Value& _internal_value() const;
  ::hillab::v4::Value* _internal_mutable_value();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.SetRequest)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 1,
      32, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr key_;
    ::hillab::v4::Value* value_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class GetResponse final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.GetResponse) */ {
 public:
  inline GetResponse() : GetResponse(nullptr) {}
  ~GetResponse() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR GetResponse(::google::protobuf::internal::ConstantInitialized);

  inline GetResponse(const GetResponse& from)
      : GetResponse(nullptr, from) {}
  GetResponse(GetResponse&& from) noexcept
    : GetResponse() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GetResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const GetResponse* internal_default_instance() {
    return reinterpret_cast<const GetResponse*>(
               &_GetResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(GetResponse& a, GetResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(GetResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GetResponse* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  GetResponse* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GetResponse>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const GetResponse& from);
  void MergeFrom(const GetResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GetResponse* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.GetResponse";
  }
  protected:
  explicit GetResponse(::google::protobuf::Arena* arena);
  GetResponse(::google::protobuf::Arena* arena, const GetResponse& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kUnitFieldNumber = 3,
    kValueFieldNumber = 2,
    kMinValueFieldNumber = 4,
    kMaxValueFieldNumber = 5,
  };
  // string key = 1;
  void clear_key() ;
  const std::string& key() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* value);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // optional string unit = 3;
  bool has_unit() const;
  void clear_unit() ;
  const std::string& unit() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_unit(Arg_&& arg, Args_... args);
  std::string* mutable_unit();
  PROTOBUF_NODISCARD std::string* release_unit();
  void set_allocated_unit(std::string* value);

  private:
  const std::string& _internal_unit() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_unit(
      const std::string& value);
  std::string* _internal_mutable_unit();

  public:
  // .hillab.v4.Value value = 2;
  bool has_value() const;
  void clear_value() ;
  const ::hillab::v4::Value& value() const;
  PROTOBUF_NODISCARD ::hillab::v4::Value* release_value();
  ::hillab::v4::Value* mutable_value();
  void set_allocated_value(::hillab::v4::Value* value);
  void unsafe_arena_set_allocated_value(::hillab::v4::Value* value);
  ::hillab::v4::Value* unsafe_arena_release_value();

  private:
  const ::hillab::v4::Value& _internal_value() const;
  ::hillab::v4::Value* _internal_mutable_value();

  public:
  // optional .hillab.v4.Value min_value = 4;
  bool has_min_value() const;
  void clear_min_value() ;
  const ::hillab::v4::Value& min_value() const;
  PROTOBUF_NODISCARD ::hillab::v4::Value* release_min_value();
  ::hillab::v4::Value* mutable_min_value();
  void set_allocated_min_value(::hillab::v4::Value* value);
  void unsafe_arena_set_allocated_min_value(::hillab::v4::Value* value);
  ::hillab::v4::Value* unsafe_arena_release_min_value();

  private:
  const ::hillab::v4::Value& _internal_min_value() const;
  ::hillab::v4::Value* _internal_mutable_min_value();

  public:
  // optional .hillab.v4.Value max_value = 5;
  bool has_max_value() const;
  void clear_max_value() ;
  const ::hillab::v4::Value& max_value() const;
  PROTOBUF_NODISCARD ::hillab::v4::Value* release_max_value();
  ::hillab::v4::Value* mutable_max_value();
  void set_allocated_max_value(::hillab::v4::Value* value);
  void unsafe_arena_set_allocated_max_value(::hillab::v4::Value* value);
  ::hillab::v4::Value* unsafe_arena_release_max_value();

  private:
  const ::hillab::v4::Value& _internal_max_value() const;
  ::hillab::v4::Value* _internal_mutable_max_value();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.GetResponse)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 5, 3,
      37, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr key_;
    ::google::protobuf::internal::ArenaStringPtr unit_;
    ::hillab::v4::Value* value_;
    ::hillab::v4::Value* min_value_;
    ::hillab::v4::Value* max_value_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};// -------------------------------------------------------------------

class BeamProfileStream final :
    public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:hillab.v4.BeamProfileStream) */ {
 public:
  inline BeamProfileStream() : BeamProfileStream(nullptr) {}
  ~BeamProfileStream() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR BeamProfileStream(::google::protobuf::internal::ConstantInitialized);

  inline BeamProfileStream(const BeamProfileStream& from)
      : BeamProfileStream(nullptr, from) {}
  BeamProfileStream(BeamProfileStream&& from) noexcept
    : BeamProfileStream() {
    *this = ::std::move(from);
  }

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

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const BeamProfileStream& default_instance() {
    return *internal_default_instance();
  }
  static inline const BeamProfileStream* internal_default_instance() {
    return reinterpret_cast<const BeamProfileStream*>(
               &_BeamProfileStream_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(BeamProfileStream& a, BeamProfileStream& b) {
    a.Swap(&b);
  }
  inline void Swap(BeamProfileStream* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr &&
        GetArena() == other->GetArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BeamProfileStream* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  BeamProfileStream* New(::google::protobuf::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BeamProfileStream>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)  final;
  void CopyFrom(const BeamProfileStream& from);
  void MergeFrom(const BeamProfileStream& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  ::google::protobuf::internal::CachedSize* AccessCachedSize() const final;
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(BeamProfileStream* other);

  private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "hillab.v4.BeamProfileStream";
  }
  protected:
  explicit BeamProfileStream(::google::protobuf::Arena* arena);
  BeamProfileStream(::google::protobuf::Arena* arena, const BeamProfileStream& from);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kBeamProfilesFieldNumber = 2,
    kTimeFieldNumber = 1,
  };
  // repeated .hillab.v4.BeamProfile beam_profiles = 2;
  int beam_profiles_size() const;
  private:
  int _internal_beam_profiles_size() const;

  public:
  void clear_beam_profiles() ;
  ::hillab::v4::BeamProfile* mutable_beam_profiles(int index);
  ::google::protobuf::RepeatedPtrField< ::hillab::v4::BeamProfile >*
      mutable_beam_profiles();
  private:
  const ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>& _internal_beam_profiles() const;
  ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>* _internal_mutable_beam_profiles();
  public:
  const ::hillab::v4::BeamProfile& beam_profiles(int index) const;
  ::hillab::v4::BeamProfile* add_beam_profiles();
  const ::google::protobuf::RepeatedPtrField< ::hillab::v4::BeamProfile >&
      beam_profiles() const;
  // .google.protobuf.Timestamp time = 1;
  bool has_time() const;
  void clear_time() ;
  const ::google::protobuf::Timestamp& time() const;
  PROTOBUF_NODISCARD ::google::protobuf::Timestamp* release_time();
  ::google::protobuf::Timestamp* mutable_time();
  void set_allocated_time(::google::protobuf::Timestamp* value);
  void unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value);
  ::google::protobuf::Timestamp* unsafe_arena_release_time();

  private:
  const ::google::protobuf::Timestamp& _internal_time() const;
  ::google::protobuf::Timestamp* _internal_mutable_time();

  public:
  // @@protoc_insertion_point(class_scope:hillab.v4.BeamProfileStream)
 private:
  class _Internal;

  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 2,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {

        inline explicit constexpr Impl_(
            ::google::protobuf::internal::ConstantInitialized) noexcept;
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena);
        inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                              ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::hillab::v4::BeamProfile > beam_profiles_;
    ::google::protobuf::Timestamp* time_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_hillab_5fbeam_5fstabilization_5fsystem_2eproto;
};

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




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


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

// Value

// bool bool_value = 1;
inline bool Value::has_bool_value() const {
  return value_case() == kBoolValue;
}
inline void Value::set_has_bool_value() {
  _impl_._oneof_case_[0] = kBoolValue;
}
inline void Value::clear_bool_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() == kBoolValue) {
    _impl_.value_.bool_value_ = false;
    clear_has_value();
  }
}
inline bool Value::bool_value() const {
  // @@protoc_insertion_point(field_get:hillab.v4.Value.bool_value)
  return _internal_bool_value();
}
inline void Value::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:hillab.v4.Value.bool_value)
}
inline bool Value::_internal_bool_value() const {
  if (value_case() == kBoolValue) {
    return _impl_.value_.bool_value_;
  }
  return false;
}
inline void Value::_internal_set_bool_value(bool value) {
  if (value_case() != kBoolValue) {
    clear_value();
    set_has_bool_value();
  }
  _impl_.value_.bool_value_ = value;
}

// int32 int_value = 2;
inline bool Value::has_int_value() const {
  return value_case() == kIntValue;
}
inline void Value::set_has_int_value() {
  _impl_._oneof_case_[0] = kIntValue;
}
inline void Value::clear_int_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() == kIntValue) {
    _impl_.value_.int_value_ = 0;
    clear_has_value();
  }
}
inline ::int32_t Value::int_value() const {
  // @@protoc_insertion_point(field_get:hillab.v4.Value.int_value)
  return _internal_int_value();
}
inline void Value::set_int_value(::int32_t value) {
  _internal_set_int_value(value);
  // @@protoc_insertion_point(field_set:hillab.v4.Value.int_value)
}
inline ::int32_t Value::_internal_int_value() const {
  if (value_case() == kIntValue) {
    return _impl_.value_.int_value_;
  }
  return 0;
}
inline void Value::_internal_set_int_value(::int32_t value) {
  if (value_case() != kIntValue) {
    clear_value();
    set_has_int_value();
  }
  _impl_.value_.int_value_ = value;
}

// float float_value = 3;
inline bool Value::has_float_value() const {
  return value_case() == kFloatValue;
}
inline void Value::set_has_float_value() {
  _impl_._oneof_case_[0] = kFloatValue;
}
inline void Value::clear_float_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() == kFloatValue) {
    _impl_.value_.float_value_ = 0;
    clear_has_value();
  }
}
inline float Value::float_value() const {
  // @@protoc_insertion_point(field_get:hillab.v4.Value.float_value)
  return _internal_float_value();
}
inline void Value::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:hillab.v4.Value.float_value)
}
inline float Value::_internal_float_value() const {
  if (value_case() == kFloatValue) {
    return _impl_.value_.float_value_;
  }
  return 0;
}
inline void Value::_internal_set_float_value(float value) {
  if (value_case() != kFloatValue) {
    clear_value();
    set_has_float_value();
  }
  _impl_.value_.float_value_ = value;
}

// string string_value = 4;
inline bool Value::has_string_value() const {
  return value_case() == kStringValue;
}
inline void Value::set_has_string_value() {
  _impl_._oneof_case_[0] = kStringValue;
}
inline void Value::clear_string_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() == kStringValue) {
    _impl_.value_.string_value_.Destroy();
    clear_has_value();
  }
}
inline const std::string& Value::string_value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.Value.string_value)
  return _internal_string_value();
}
inline PROTOBUF_ALWAYS_INLINE void Value::set_string_value(const char* str) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() != kStringValue) {
    clear_value();

    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  _impl_.value_.string_value_.Set(str, GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.Value.string_value)
}
inline std::string* Value::mutable_string_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_string_value();
  // @@protoc_insertion_point(field_mutable:hillab.v4.Value.string_value)
  return _s;
}
inline const std::string& Value::_internal_string_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (value_case() != kStringValue) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.value_.string_value_.Get();
}
inline void Value::_internal_set_string_value(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() != kStringValue) {
    clear_value();

    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  _impl_.value_.string_value_.Set(value, GetArena());
}
inline std::string* Value::_internal_mutable_string_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value_case() != kStringValue) {
    clear_value();

    set_has_string_value();
    _impl_.value_.string_value_.InitDefault();
  }
  return _impl_.value_.string_value_.Mutable( GetArena());
}
inline std::string* Value::release_string_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.Value.string_value)
  if (value_case() != kStringValue) {
    return nullptr;
  }
  clear_has_value();
  return _impl_.value_.string_value_.Release();
}
inline void Value::set_allocated_string_value(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_value()) {
    clear_value();
  }
  if (value != nullptr) {
    set_has_string_value();
    _impl_.value_.string_value_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.Value.string_value)
}

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

// SetRequest

// string key = 1;
inline void SetRequest::clear_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.ClearToEmpty();
}
inline const std::string& SetRequest::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.SetRequest.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SetRequest::set_key(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.SetRequest.key)
}
inline std::string* SetRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:hillab.v4.SetRequest.key)
  return _s;
}
inline const std::string& SetRequest::_internal_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.key_.Get();
}
inline void SetRequest::_internal_set_key(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(value, GetArena());
}
inline std::string* SetRequest::_internal_mutable_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.key_.Mutable( GetArena());
}
inline std::string* SetRequest::release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.SetRequest.key)
  return _impl_.key_.Release();
}
inline void SetRequest::set_allocated_key(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.SetRequest.key)
}

// .hillab.v4.Value value = 2;
inline bool SetRequest::has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline void SetRequest::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::hillab::v4::Value& SetRequest::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::hillab::v4::Value* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::hillab::v4::Value&>(::hillab::v4::_Value_default_instance_);
}
inline const ::hillab::v4::Value& SetRequest::value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.SetRequest.value)
  return _internal_value();
}
inline void SetRequest::unsafe_arena_set_allocated_value(::hillab::v4::Value* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.SetRequest.value)
}
inline ::hillab::v4::Value* SetRequest::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::hillab::v4::Value* released = _impl_.value_;
  _impl_.value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::hillab::v4::Value* SetRequest::unsafe_arena_release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.SetRequest.value)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::hillab::v4::Value* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::hillab::v4::Value* SetRequest::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::hillab::v4::Value>(GetArena());
    _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(p);
  }
  return _impl_.value_;
}
inline ::hillab::v4::Value* SetRequest::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::hillab::v4::Value* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:hillab.v4.SetRequest.value)
  return _msg;
}
inline void SetRequest::set_allocated_value(::hillab::v4::Value* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::hillab::v4::Value*>(_impl_.value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::hillab::v4::Value*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.SetRequest.value)
}

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

// GetRequest

// string key = 1;
inline void GetRequest::clear_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.ClearToEmpty();
}
inline const std::string& GetRequest::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetRequest.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GetRequest::set_key(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.GetRequest.key)
}
inline std::string* GetRequest::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetRequest.key)
  return _s;
}
inline const std::string& GetRequest::_internal_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.key_.Get();
}
inline void GetRequest::_internal_set_key(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(value, GetArena());
}
inline std::string* GetRequest::_internal_mutable_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.key_.Mutable( GetArena());
}
inline std::string* GetRequest::release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetRequest.key)
  return _impl_.key_.Release();
}
inline void GetRequest::set_allocated_key(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetRequest.key)
}

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

// GetResponse

// string key = 1;
inline void GetResponse::clear_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.ClearToEmpty();
}
inline const std::string& GetResponse::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetResponse.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GetResponse::set_key(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.GetResponse.key)
}
inline std::string* GetResponse::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetResponse.key)
  return _s;
}
inline const std::string& GetResponse::_internal_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.key_.Get();
}
inline void GetResponse::_internal_set_key(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.key_.Set(value, GetArena());
}
inline std::string* GetResponse::_internal_mutable_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.key_.Mutable( GetArena());
}
inline std::string* GetResponse::release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetResponse.key)
  return _impl_.key_.Release();
}
inline void GetResponse::set_allocated_key(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetResponse.key)
}

// .hillab.v4.Value value = 2;
inline bool GetResponse::has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline void GetResponse::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::hillab::v4::Value& GetResponse::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::hillab::v4::Value* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::hillab::v4::Value&>(::hillab::v4::_Value_default_instance_);
}
inline const ::hillab::v4::Value& GetResponse::value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetResponse.value)
  return _internal_value();
}
inline void GetResponse::unsafe_arena_set_allocated_value(::hillab::v4::Value* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.GetResponse.value)
}
inline ::hillab::v4::Value* GetResponse::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::hillab::v4::Value* released = _impl_.value_;
  _impl_.value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::hillab::v4::Value* GetResponse::unsafe_arena_release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetResponse.value)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::hillab::v4::Value* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::hillab::v4::Value* GetResponse::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::hillab::v4::Value>(GetArena());
    _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(p);
  }
  return _impl_.value_;
}
inline ::hillab::v4::Value* GetResponse::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::hillab::v4::Value* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetResponse.value)
  return _msg;
}
inline void GetResponse::set_allocated_value(::hillab::v4::Value* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::hillab::v4::Value*>(_impl_.value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::hillab::v4::Value*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetResponse.value)
}

// optional string unit = 3;
inline bool GetResponse::has_unit() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void GetResponse::clear_unit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.unit_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GetResponse::unit() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetResponse.unit)
  return _internal_unit();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GetResponse::set_unit(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.unit_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.GetResponse.unit)
}
inline std::string* GetResponse::mutable_unit() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_unit();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetResponse.unit)
  return _s;
}
inline const std::string& GetResponse::_internal_unit() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.unit_.Get();
}
inline void GetResponse::_internal_set_unit(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.unit_.Set(value, GetArena());
}
inline std::string* GetResponse::_internal_mutable_unit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.unit_.Mutable( GetArena());
}
inline std::string* GetResponse::release_unit() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetResponse.unit)
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* released = _impl_.unit_.Release();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.unit_.Set("", GetArena());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return released;
}
inline void GetResponse::set_allocated_unit(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.unit_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.unit_.IsDefault()) {
          _impl_.unit_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetResponse.unit)
}

// optional .hillab.v4.Value min_value = 4;
inline bool GetResponse::has_min_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.min_value_ != nullptr);
  return value;
}
inline void GetResponse::clear_min_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.min_value_ != nullptr) _impl_.min_value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::hillab::v4::Value& GetResponse::_internal_min_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::hillab::v4::Value* p = _impl_.min_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::hillab::v4::Value&>(::hillab::v4::_Value_default_instance_);
}
inline const ::hillab::v4::Value& GetResponse::min_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetResponse.min_value)
  return _internal_min_value();
}
inline void GetResponse::unsafe_arena_set_allocated_min_value(::hillab::v4::Value* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.min_value_);
  }
  _impl_.min_value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.GetResponse.min_value)
}
inline ::hillab::v4::Value* GetResponse::release_min_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::hillab::v4::Value* released = _impl_.min_value_;
  _impl_.min_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::hillab::v4::Value* GetResponse::unsafe_arena_release_min_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetResponse.min_value)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::hillab::v4::Value* temp = _impl_.min_value_;
  _impl_.min_value_ = nullptr;
  return temp;
}
inline ::hillab::v4::Value* GetResponse::_internal_mutable_min_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.min_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::hillab::v4::Value>(GetArena());
    _impl_.min_value_ = reinterpret_cast<::hillab::v4::Value*>(p);
  }
  return _impl_.min_value_;
}
inline ::hillab::v4::Value* GetResponse::mutable_min_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::hillab::v4::Value* _msg = _internal_mutable_min_value();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetResponse.min_value)
  return _msg;
}
inline void GetResponse::set_allocated_min_value(::hillab::v4::Value* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::hillab::v4::Value*>(_impl_.min_value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::hillab::v4::Value*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.min_value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetResponse.min_value)
}

// optional .hillab.v4.Value max_value = 5;
inline bool GetResponse::has_max_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.max_value_ != nullptr);
  return value;
}
inline void GetResponse::clear_max_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.max_value_ != nullptr) _impl_.max_value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::hillab::v4::Value& GetResponse::_internal_max_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::hillab::v4::Value* p = _impl_.max_value_;
  return p != nullptr ? *p : reinterpret_cast<const ::hillab::v4::Value&>(::hillab::v4::_Value_default_instance_);
}
inline const ::hillab::v4::Value& GetResponse::max_value() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.GetResponse.max_value)
  return _internal_max_value();
}
inline void GetResponse::unsafe_arena_set_allocated_max_value(::hillab::v4::Value* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.max_value_);
  }
  _impl_.max_value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.GetResponse.max_value)
}
inline ::hillab::v4::Value* GetResponse::release_max_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::hillab::v4::Value* released = _impl_.max_value_;
  _impl_.max_value_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::hillab::v4::Value* GetResponse::unsafe_arena_release_max_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.GetResponse.max_value)

  _impl_._has_bits_[0] &= ~0x00000008u;
  ::hillab::v4::Value* temp = _impl_.max_value_;
  _impl_.max_value_ = nullptr;
  return temp;
}
inline ::hillab::v4::Value* GetResponse::_internal_mutable_max_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.max_value_ == nullptr) {
    auto* p = CreateMaybeMessage<::hillab::v4::Value>(GetArena());
    _impl_.max_value_ = reinterpret_cast<::hillab::v4::Value*>(p);
  }
  return _impl_.max_value_;
}
inline ::hillab::v4::Value* GetResponse::mutable_max_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::hillab::v4::Value* _msg = _internal_mutable_max_value();
  // @@protoc_insertion_point(field_mutable:hillab.v4.GetResponse.max_value)
  return _msg;
}
inline void GetResponse::set_allocated_max_value(::hillab::v4::Value* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::hillab::v4::Value*>(_impl_.max_value_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::hillab::v4::Value*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }

  _impl_.max_value_ = reinterpret_cast<::hillab::v4::Value*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.GetResponse.max_value)
}

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

// BeamProfile

// int32 index = 1;
inline void BeamProfile::clear_index() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.index_ = 0;
}
inline ::int32_t BeamProfile::index() const {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfile.index)
  return _internal_index();
}
inline void BeamProfile::set_index(::int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:hillab.v4.BeamProfile.index)
}
inline ::int32_t BeamProfile::_internal_index() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.index_;
}
inline void BeamProfile::_internal_set_index(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.index_ = value;
}

// double latest_value = 2;
inline void BeamProfile::clear_latest_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.latest_value_ = 0;
}
inline double BeamProfile::latest_value() const {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfile.latest_value)
  return _internal_latest_value();
}
inline void BeamProfile::set_latest_value(double value) {
  _internal_set_latest_value(value);
  // @@protoc_insertion_point(field_set:hillab.v4.BeamProfile.latest_value)
}
inline double BeamProfile::_internal_latest_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.latest_value_;
}
inline void BeamProfile::_internal_set_latest_value(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.latest_value_ = value;
}

// double average = 3;
inline void BeamProfile::clear_average() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.average_ = 0;
}
inline double BeamProfile::average() const {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfile.average)
  return _internal_average();
}
inline void BeamProfile::set_average(double value) {
  _internal_set_average(value);
  // @@protoc_insertion_point(field_set:hillab.v4.BeamProfile.average)
}
inline double BeamProfile::_internal_average() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.average_;
}
inline void BeamProfile::_internal_set_average(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.average_ = value;
}

// double standard_deviation = 4;
inline void BeamProfile::clear_standard_deviation() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.standard_deviation_ = 0;
}
inline double BeamProfile::standard_deviation() const {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfile.standard_deviation)
  return _internal_standard_deviation();
}
inline void BeamProfile::set_standard_deviation(double value) {
  _internal_set_standard_deviation(value);
  // @@protoc_insertion_point(field_set:hillab.v4.BeamProfile.standard_deviation)
}
inline double BeamProfile::_internal_standard_deviation() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.standard_deviation_;
}
inline void BeamProfile::_internal_set_standard_deviation(double value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.standard_deviation_ = value;
}

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

// BeamProfileStream

// .google.protobuf.Timestamp time = 1;
inline bool BeamProfileStream::has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.time_ != nullptr);
  return value;
}
inline const ::google::protobuf::Timestamp& BeamProfileStream::_internal_time() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::google::protobuf::Timestamp* p = _impl_.time_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Timestamp&>(::google::protobuf::_Timestamp_default_instance_);
}
inline const ::google::protobuf::Timestamp& BeamProfileStream::time() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfileStream.time)
  return _internal_time();
}
inline void BeamProfileStream::unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }
  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.BeamProfileStream.time)
}
inline ::google::protobuf::Timestamp* BeamProfileStream::release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* released = _impl_.time_;
  _impl_.time_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::google::protobuf::Timestamp* BeamProfileStream::unsafe_arena_release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.BeamProfileStream.time)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* temp = _impl_.time_;
  _impl_.time_ = nullptr;
  return temp;
}
inline ::google::protobuf::Timestamp* BeamProfileStream::_internal_mutable_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.time_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena());
    _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(p);
  }
  return _impl_.time_;
}
inline ::google::protobuf::Timestamp* BeamProfileStream::mutable_time() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::Timestamp* _msg = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:hillab.v4.BeamProfileStream.time)
  return _msg;
}
inline void BeamProfileStream::set_allocated_time(::google::protobuf::Timestamp* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.BeamProfileStream.time)
}

// repeated .hillab.v4.BeamProfile beam_profiles = 2;
inline int BeamProfileStream::_internal_beam_profiles_size() const {
  return _internal_beam_profiles().size();
}
inline int BeamProfileStream::beam_profiles_size() const {
  return _internal_beam_profiles_size();
}
inline void BeamProfileStream::clear_beam_profiles() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.beam_profiles_.Clear();
}
inline ::hillab::v4::BeamProfile* BeamProfileStream::mutable_beam_profiles(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:hillab.v4.BeamProfileStream.beam_profiles)
  return _internal_mutable_beam_profiles()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>* BeamProfileStream::mutable_beam_profiles()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:hillab.v4.BeamProfileStream.beam_profiles)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_beam_profiles();
}
inline const ::hillab::v4::BeamProfile& BeamProfileStream::beam_profiles(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.BeamProfileStream.beam_profiles)
  return _internal_beam_profiles().Get(index);
}
inline ::hillab::v4::BeamProfile* BeamProfileStream::add_beam_profiles() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::hillab::v4::BeamProfile* _add = _internal_mutable_beam_profiles()->Add();
  // @@protoc_insertion_point(field_add:hillab.v4.BeamProfileStream.beam_profiles)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>& BeamProfileStream::beam_profiles() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:hillab.v4.BeamProfileStream.beam_profiles)
  return _internal_beam_profiles();
}
inline const ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>&
BeamProfileStream::_internal_beam_profiles() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.beam_profiles_;
}
inline ::google::protobuf::RepeatedPtrField<::hillab::v4::BeamProfile>*
BeamProfileStream::_internal_mutable_beam_profiles() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.beam_profiles_;
}

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

// AppInfoResponse

// string version = 1;
inline void AppInfoResponse::clear_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.ClearToEmpty();
}
inline const std::string& AppInfoResponse::version() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.AppInfoResponse.version)
  return _internal_version();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void AppInfoResponse::set_version(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.AppInfoResponse.version)
}
inline std::string* AppInfoResponse::mutable_version() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:hillab.v4.AppInfoResponse.version)
  return _s;
}
inline const std::string& AppInfoResponse::_internal_version() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.version_.Get();
}
inline void AppInfoResponse::_internal_set_version(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.version_.Set(value, GetArena());
}
inline std::string* AppInfoResponse::_internal_mutable_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.version_.Mutable( GetArena());
}
inline std::string* AppInfoResponse::release_version() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.AppInfoResponse.version)
  return _impl_.version_.Release();
}
inline void AppInfoResponse::set_allocated_version(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.version_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.version_.IsDefault()) {
          _impl_.version_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.AppInfoResponse.version)
}

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

// PresetRequest

// string name = 1;
inline void PresetRequest::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PresetRequest::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.PresetRequest.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PresetRequest::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.PresetRequest.name)
}
inline std::string* PresetRequest::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:hillab.v4.PresetRequest.name)
  return _s;
}
inline const std::string& PresetRequest::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PresetRequest::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PresetRequest::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PresetRequest::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.PresetRequest.name)
  return _impl_.name_.Release();
}
inline void PresetRequest::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.PresetRequest.name)
}

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

// PresetResponse

// string name = 1;
inline void PresetResponse::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& PresetResponse::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.PresetResponse.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void PresetResponse::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.PresetResponse.name)
}
inline std::string* PresetResponse::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:hillab.v4.PresetResponse.name)
  return _s;
}
inline const std::string& PresetResponse::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void PresetResponse::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.name_.Set(value, GetArena());
}
inline std::string* PresetResponse::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* PresetResponse::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.PresetResponse.name)
  return _impl_.name_.Release();
}
inline void PresetResponse::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.PresetResponse.name)
}

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

// PresetListResponse

// repeated string name_list = 1;
inline int PresetListResponse::_internal_name_list_size() const {
  return _internal_name_list().size();
}
inline int PresetListResponse::name_list_size() const {
  return _internal_name_list_size();
}
inline void PresetListResponse::clear_name_list() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_list_.Clear();
}
inline std::string* PresetListResponse::add_name_list()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  std::string* _s = _internal_mutable_name_list()->Add();
  // @@protoc_insertion_point(field_add_mutable:hillab.v4.PresetListResponse.name_list)
  return _s;
}
inline const std::string& PresetListResponse::name_list(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.PresetListResponse.name_list)
  return _internal_name_list().Get(index);
}
inline std::string* PresetListResponse::mutable_name_list(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:hillab.v4.PresetListResponse.name_list)
  return _internal_mutable_name_list()->Mutable(index);
}
inline void PresetListResponse::set_name_list(int index, const std::string& value) {
  _internal_mutable_name_list()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::set_name_list(int index, std::string&& value) {
  _internal_mutable_name_list()->Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::set_name_list(int index, const char* value) {
  ABSL_DCHECK(value != nullptr);
  _internal_mutable_name_list()->Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::set_name_list(int index, const char* value,
                              std::size_t size) {
  _internal_mutable_name_list()->Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::set_name_list(int index, absl::string_view value) {
  _internal_mutable_name_list()->Mutable(index)->assign(value.data(),
                                                     value.size());
  // @@protoc_insertion_point(field_set_string_piece:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::add_name_list(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_name_list()->Add()->assign(value);
  // @@protoc_insertion_point(field_add:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::add_name_list(std::string&& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_name_list()->Add(std::move(value));
  // @@protoc_insertion_point(field_add:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::add_name_list(const char* value) {
  ABSL_DCHECK(value != nullptr);
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_name_list()->Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::add_name_list(const char* value, std::size_t size) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_name_list()->Add()->assign(
      reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:hillab.v4.PresetListResponse.name_list)
}
inline void PresetListResponse::add_name_list(absl::string_view value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _internal_mutable_name_list()->Add()->assign(value.data(), value.size());
  // @@protoc_insertion_point(field_add_string_piece:hillab.v4.PresetListResponse.name_list)
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
PresetListResponse::name_list() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:hillab.v4.PresetListResponse.name_list)
  return _internal_name_list();
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
PresetListResponse::mutable_name_list() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:hillab.v4.PresetListResponse.name_list)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_name_list();
}
inline const ::google::protobuf::RepeatedPtrField<std::string>&
PresetListResponse::_internal_name_list() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_list_;
}
inline ::google::protobuf::RepeatedPtrField<std::string>*
PresetListResponse::_internal_mutable_name_list() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.name_list_;
}

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

// ImageStreamServerRequest

// optional bool running = 1;
inline bool ImageStreamServerRequest::has_running() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline void ImageStreamServerRequest::clear_running() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.running_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool ImageStreamServerRequest::running() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerRequest.running)
  return _internal_running();
}
inline void ImageStreamServerRequest::set_running(bool value) {
  _internal_set_running(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerRequest.running)
}
inline bool ImageStreamServerRequest::_internal_running() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.running_;
}
inline void ImageStreamServerRequest::_internal_set_running(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.running_ = value;
}

// optional int32 mtu = 2;
inline bool ImageStreamServerRequest::has_mtu() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline void ImageStreamServerRequest::clear_mtu() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.mtu_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::int32_t ImageStreamServerRequest::mtu() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerRequest.mtu)
  return _internal_mtu();
}
inline void ImageStreamServerRequest::set_mtu(::int32_t value) {
  _internal_set_mtu(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerRequest.mtu)
}
inline ::int32_t ImageStreamServerRequest::_internal_mtu() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.mtu_;
}
inline void ImageStreamServerRequest::_internal_set_mtu(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mtu_ = value;
}

// optional int32 downscale = 3;
inline bool ImageStreamServerRequest::has_downscale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline void ImageStreamServerRequest::clear_downscale() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.downscale_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::int32_t ImageStreamServerRequest::downscale() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerRequest.downscale)
  return _internal_downscale();
}
inline void ImageStreamServerRequest::set_downscale(::int32_t value) {
  _internal_set_downscale(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerRequest.downscale)
}
inline ::int32_t ImageStreamServerRequest::_internal_downscale() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.downscale_;
}
inline void ImageStreamServerRequest::_internal_set_downscale(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.downscale_ = value;
}

// optional bool auto_running = 4;
inline bool ImageStreamServerRequest::has_auto_running() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline void ImageStreamServerRequest::clear_auto_running() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.auto_running_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool ImageStreamServerRequest::auto_running() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerRequest.auto_running)
  return _internal_auto_running();
}
inline void ImageStreamServerRequest::set_auto_running(bool value) {
  _internal_set_auto_running(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerRequest.auto_running)
}
inline bool ImageStreamServerRequest::_internal_auto_running() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.auto_running_;
}
inline void ImageStreamServerRequest::_internal_set_auto_running(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.auto_running_ = value;
}

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

// ImageStreamServerResponse

// string ip = 1;
inline void ImageStreamServerResponse::clear_ip() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ip_.ClearToEmpty();
}
inline const std::string& ImageStreamServerResponse::ip() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.ip)
  return _internal_ip();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ImageStreamServerResponse::set_ip(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ip_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.ip)
}
inline std::string* ImageStreamServerResponse::mutable_ip() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:hillab.v4.ImageStreamServerResponse.ip)
  return _s;
}
inline const std::string& ImageStreamServerResponse::_internal_ip() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.ip_.Get();
}
inline void ImageStreamServerResponse::_internal_set_ip(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.ip_.Set(value, GetArena());
}
inline std::string* ImageStreamServerResponse::_internal_mutable_ip() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.ip_.Mutable( GetArena());
}
inline std::string* ImageStreamServerResponse::release_ip() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.ImageStreamServerResponse.ip)
  return _impl_.ip_.Release();
}
inline void ImageStreamServerResponse::set_allocated_ip(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.ip_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.ip_.IsDefault()) {
          _impl_.ip_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.ImageStreamServerResponse.ip)
}

// int32 port = 2;
inline void ImageStreamServerResponse::clear_port() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.port_ = 0;
}
inline ::int32_t ImageStreamServerResponse::port() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.port)
  return _internal_port();
}
inline void ImageStreamServerResponse::set_port(::int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.port)
}
inline ::int32_t ImageStreamServerResponse::_internal_port() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.port_;
}
inline void ImageStreamServerResponse::_internal_set_port(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.port_ = value;
}

// int32 mtu = 3;
inline void ImageStreamServerResponse::clear_mtu() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.mtu_ = 0;
}
inline ::int32_t ImageStreamServerResponse::mtu() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.mtu)
  return _internal_mtu();
}
inline void ImageStreamServerResponse::set_mtu(::int32_t value) {
  _internal_set_mtu(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.mtu)
}
inline ::int32_t ImageStreamServerResponse::_internal_mtu() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.mtu_;
}
inline void ImageStreamServerResponse::_internal_set_mtu(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.mtu_ = value;
}

// int32 downscale = 4;
inline void ImageStreamServerResponse::clear_downscale() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.downscale_ = 0;
}
inline ::int32_t ImageStreamServerResponse::downscale() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.downscale)
  return _internal_downscale();
}
inline void ImageStreamServerResponse::set_downscale(::int32_t value) {
  _internal_set_downscale(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.downscale)
}
inline ::int32_t ImageStreamServerResponse::_internal_downscale() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.downscale_;
}
inline void ImageStreamServerResponse::_internal_set_downscale(::int32_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.downscale_ = value;
}

// bool running = 5;
inline void ImageStreamServerResponse::clear_running() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.running_ = false;
}
inline bool ImageStreamServerResponse::running() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.running)
  return _internal_running();
}
inline void ImageStreamServerResponse::set_running(bool value) {
  _internal_set_running(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.running)
}
inline bool ImageStreamServerResponse::_internal_running() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.running_;
}
inline void ImageStreamServerResponse::_internal_set_running(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.running_ = value;
}

// bool auto_running = 6;
inline void ImageStreamServerResponse::clear_auto_running() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.auto_running_ = false;
}
inline bool ImageStreamServerResponse::auto_running() const {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.auto_running)
  return _internal_auto_running();
}
inline void ImageStreamServerResponse::set_auto_running(bool value) {
  _internal_set_auto_running(value);
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.auto_running)
}
inline bool ImageStreamServerResponse::_internal_auto_running() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.auto_running_;
}
inline void ImageStreamServerResponse::_internal_set_auto_running(bool value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.auto_running_ = value;
}

// string sdp = 7;
inline void ImageStreamServerResponse::clear_sdp() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sdp_.ClearToEmpty();
}
inline const std::string& ImageStreamServerResponse::sdp() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.ImageStreamServerResponse.sdp)
  return _internal_sdp();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void ImageStreamServerResponse::set_sdp(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sdp_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.ImageStreamServerResponse.sdp)
}
inline std::string* ImageStreamServerResponse::mutable_sdp() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_sdp();
  // @@protoc_insertion_point(field_mutable:hillab.v4.ImageStreamServerResponse.sdp)
  return _s;
}
inline const std::string& ImageStreamServerResponse::_internal_sdp() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.sdp_.Get();
}
inline void ImageStreamServerResponse::_internal_set_sdp(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.sdp_.Set(value, GetArena());
}
inline std::string* ImageStreamServerResponse::_internal_mutable_sdp() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.sdp_.Mutable( GetArena());
}
inline std::string* ImageStreamServerResponse::release_sdp() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.ImageStreamServerResponse.sdp)
  return _impl_.sdp_.Release();
}
inline void ImageStreamServerResponse::set_allocated_sdp(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.sdp_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.sdp_.IsDefault()) {
          _impl_.sdp_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.ImageStreamServerResponse.sdp)
}

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

// SystemLogStream

// .google.protobuf.Timestamp time = 1;
inline bool SystemLogStream::has_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.time_ != nullptr);
  return value;
}
inline const ::google::protobuf::Timestamp& SystemLogStream::_internal_time() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::google::protobuf::Timestamp* p = _impl_.time_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Timestamp&>(::google::protobuf::_Timestamp_default_instance_);
}
inline const ::google::protobuf::Timestamp& SystemLogStream::time() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.SystemLogStream.time)
  return _internal_time();
}
inline void SystemLogStream::unsafe_arena_set_allocated_time(::google::protobuf::Timestamp* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }
  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:hillab.v4.SystemLogStream.time)
}
inline ::google::protobuf::Timestamp* SystemLogStream::release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* released = _impl_.time_;
  _impl_.time_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::google::protobuf::Timestamp* SystemLogStream::unsafe_arena_release_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.SystemLogStream.time)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Timestamp* temp = _impl_.time_;
  _impl_.time_ = nullptr;
  return temp;
}
inline ::google::protobuf::Timestamp* SystemLogStream::_internal_mutable_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.time_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::protobuf::Timestamp>(GetArena());
    _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(p);
  }
  return _impl_.time_;
}
inline ::google::protobuf::Timestamp* SystemLogStream::mutable_time() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::Timestamp* _msg = _internal_mutable_time();
  // @@protoc_insertion_point(field_mutable:hillab.v4.SystemLogStream.time)
  return _msg;
}
inline void SystemLogStream::set_allocated_time(::google::protobuf::Timestamp* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.time_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.SystemLogStream.time)
}

// .hillab.v4.SystemLogType type = 2;
inline void SystemLogStream::clear_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_ = 0;
}
inline ::hillab::v4::SystemLogType SystemLogStream::type() const {
  // @@protoc_insertion_point(field_get:hillab.v4.SystemLogStream.type)
  return _internal_type();
}
inline void SystemLogStream::set_type(::hillab::v4::SystemLogType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:hillab.v4.SystemLogStream.type)
}
inline ::hillab::v4::SystemLogType SystemLogStream::_internal_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return static_cast<::hillab::v4::SystemLogType>(_impl_.type_);
}
inline void SystemLogStream::_internal_set_type(::hillab::v4::SystemLogType value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.type_ = value;
}

// string message = 3;
inline void SystemLogStream::clear_message() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.message_.ClearToEmpty();
}
inline const std::string& SystemLogStream::message() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:hillab.v4.SystemLogStream.message)
  return _internal_message();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void SystemLogStream::set_message(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.message_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:hillab.v4.SystemLogStream.message)
}
inline std::string* SystemLogStream::mutable_message() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:hillab.v4.SystemLogStream.message)
  return _s;
}
inline const std::string& SystemLogStream::_internal_message() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.message_.Get();
}
inline void SystemLogStream::_internal_set_message(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  _impl_.message_.Set(value, GetArena());
}
inline std::string* SystemLogStream::_internal_mutable_message() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ;
  return _impl_.message_.Mutable( GetArena());
}
inline std::string* SystemLogStream::release_message() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:hillab.v4.SystemLogStream.message)
  return _impl_.message_.Release();
}
inline void SystemLogStream::set_allocated_message(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.message_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.message_.IsDefault()) {
          _impl_.message_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:hillab.v4.SystemLogStream.message)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v4
}  // namespace hillab


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::hillab::v4::SystemLogType> : std::true_type {};

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_hillab_5fbeam_5fstabilization_5fsystem_2eproto_2epb_2eh
