// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: proto/alarm/v1/stream.proto
// Protobuf C++ Version: 7.35.1

#ifndef proto_2falarm_2fv1_2fstream_2eproto_2epb_2eh
#define proto_2falarm_2fv1_2fstream_2eproto_2epb_2eh

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

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7035001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#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/generated_message_reflection.h"
#include "google/protobuf/message.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_reflection.h"
#include "google/protobuf/unknown_field_set.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_proto_2falarm_2fv1_2fstream_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2falarm_2fv1_2fstream_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_proto_2falarm_2fv1_2fstream_2eproto;
}  // extern "C"
namespace alarms {
namespace v1 {
enum AlarmLogStatus : int;
extern const uint32_t AlarmLogStatus_internal_data_[];
enum AlarmStatus : int;
extern const uint32_t AlarmStatus_internal_data_[];
class AlarmCheckpoint;
struct AlarmCheckpointGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AlarmCheckpointGlobalsTypeInternal AlarmCheckpoint_globals_;
extern const ::google::protobuf::internal::ClassDataFull AlarmCheckpoint_class_data_;
#else
extern const AlarmCheckpointGlobalsTypeInternal AlarmCheckpoint_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AlarmLogEntry;
struct AlarmLogEntryGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AlarmLogEntryGlobalsTypeInternal AlarmLogEntry_globals_;
extern const ::google::protobuf::internal::ClassDataFull AlarmLogEntry_class_data_;
#else
extern const AlarmLogEntryGlobalsTypeInternal AlarmLogEntry_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AlarmLogHealth;
struct AlarmLogHealthGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AlarmLogHealthGlobalsTypeInternal AlarmLogHealth_globals_;
extern const ::google::protobuf::internal::ClassDataFull AlarmLogHealth_class_data_;
#else
extern const AlarmLogHealthGlobalsTypeInternal AlarmLogHealth_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class AlarmSnapshot;
struct AlarmSnapshotGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AlarmSnapshotGlobalsTypeInternal AlarmSnapshot_globals_;
extern const ::google::protobuf::internal::ClassDataFull AlarmSnapshot_class_data_;
#else
extern const AlarmSnapshotGlobalsTypeInternal AlarmSnapshot_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class LogEntries;
struct LogEntriesGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern LogEntriesGlobalsTypeInternal LogEntries_globals_;
extern const ::google::protobuf::internal::ClassDataFull LogEntries_class_data_;
#else
extern const LogEntriesGlobalsTypeInternal LogEntries_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SendAlarmCheckpoint;
struct SendAlarmCheckpointGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SendAlarmCheckpointGlobalsTypeInternal SendAlarmCheckpoint_globals_;
extern const ::google::protobuf::internal::ClassDataFull SendAlarmCheckpoint_class_data_;
#else
extern const SendAlarmCheckpointGlobalsTypeInternal SendAlarmCheckpoint_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SendAlarmLogHealth;
struct SendAlarmLogHealthGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SendAlarmLogHealthGlobalsTypeInternal SendAlarmLogHealth_globals_;
extern const ::google::protobuf::internal::ClassDataFull SendAlarmLogHealth_class_data_;
#else
extern const SendAlarmLogHealthGlobalsTypeInternal SendAlarmLogHealth_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SendAlarmSnapshot;
struct SendAlarmSnapshotGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SendAlarmSnapshotGlobalsTypeInternal SendAlarmSnapshot_globals_;
extern const ::google::protobuf::internal::ClassDataFull SendAlarmSnapshot_class_data_;
#else
extern const SendAlarmSnapshotGlobalsTypeInternal SendAlarmSnapshot_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class StartAlarmStreaming;
struct StartAlarmStreamingGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern StartAlarmStreamingGlobalsTypeInternal StartAlarmStreaming_globals_;
extern const ::google::protobuf::internal::ClassDataFull StartAlarmStreaming_class_data_;
#else
extern const StartAlarmStreamingGlobalsTypeInternal StartAlarmStreaming_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace v1
}  // namespace alarms
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::alarms::v1::AlarmLogStatus_internal_data_>
    internal::EnumTraitsImpl::value<::alarms::v1::AlarmLogStatus>;
template <>
internal::EnumTraitsT<::alarms::v1::AlarmStatus_internal_data_>
    internal::EnumTraitsImpl::value<::alarms::v1::AlarmStatus>;
}  // namespace protobuf
}  // namespace google

namespace alarms {
namespace v1 {
enum AlarmLogStatus : int {
  ALARM_LOG_STATUS_UNSPECIFIED = 0,
  ALARM_LOG_STATUS_RUNNING = 1,
  ALARM_LOG_STATUS_IDLE = 2,
  AlarmLogStatus_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  AlarmLogStatus_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t AlarmLogStatus_internal_data_[];
inline constexpr AlarmLogStatus AlarmLogStatus_MIN =
    static_cast<AlarmLogStatus>(0);
inline constexpr AlarmLogStatus AlarmLogStatus_MAX =
    static_cast<AlarmLogStatus>(2);
[[nodiscard]] inline bool AlarmLogStatus_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int AlarmLogStatus_ARRAYSIZE = 2 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
AlarmLogStatus_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(AlarmLogStatus) {
  return AlarmLogStatus_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& AlarmLogStatus_Name(T value) {
  static_assert(::std::is_same<T, AlarmLogStatus>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to AlarmLogStatus_Name().");
  return AlarmLogStatus_Name(static_cast<AlarmLogStatus>(value));
}
template <>
[[nodiscard]] inline const ::std::string& AlarmLogStatus_Name(AlarmLogStatus value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlarmLogStatus_descriptor, 0, 2>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool AlarmLogStatus_Parse(
    ::absl::string_view name, AlarmLogStatus* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<AlarmLogStatus>(AlarmLogStatus_descriptor(), name,
                                           value);
}
enum AlarmStatus : int {
  ALARM_STATUS_NULL = 0,
  ALARM_STATUS_UNKNOWN = 1,
  ALARM_STATUS_REMOVED = 2,
  ALARM_STATUS_NOT_A_NUMBER = 3,
  ALARM_STATUS_CLEAR = 4,
  ALARM_STATUS_WARNING = 5,
  ALARM_STATUS_CRITICAL = 6,
  AlarmStatus_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  AlarmStatus_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};

extern const uint32_t AlarmStatus_internal_data_[];
inline constexpr AlarmStatus AlarmStatus_MIN =
    static_cast<AlarmStatus>(0);
inline constexpr AlarmStatus AlarmStatus_MAX =
    static_cast<AlarmStatus>(6);
[[nodiscard]] inline bool AlarmStatus_IsValid(int value) {
  return 0 <= value && value <= 6;
}
inline constexpr int AlarmStatus_ARRAYSIZE = 6 + 1;
[[nodiscard]] const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL
AlarmStatus_descriptor();
[[nodiscard]] inline auto ProtobufInternalGetEnumDescriptor(AlarmStatus) {
  return AlarmStatus_descriptor();
}
template <typename T>
[[nodiscard]] const ::std::string& AlarmStatus_Name(T value) {
  static_assert(::std::is_same<T, AlarmStatus>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to AlarmStatus_Name().");
  return AlarmStatus_Name(static_cast<AlarmStatus>(value));
}
template <>
[[nodiscard]] inline const ::std::string& AlarmStatus_Name(AlarmStatus value) {
  return ::google::protobuf::internal::NameOfDenseEnum<AlarmStatus_descriptor, 0, 6>(
      static_cast<int>(value));
}
[[nodiscard]] inline bool AlarmStatus_Parse(
    ::absl::string_view name, AlarmStatus* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<AlarmStatus>(AlarmStatus_descriptor(), name,
                                           value);
}
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

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


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

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED StartAlarmStreaming final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.StartAlarmStreaming) */ {
 public:
  inline StartAlarmStreaming() : StartAlarmStreaming(nullptr) {}
  ~StartAlarmStreaming() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(StartAlarmStreaming* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(StartAlarmStreaming));
  }
#endif

  template <typename = void>
  explicit constexpr StartAlarmStreaming(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline StartAlarmStreaming(const StartAlarmStreaming& from) : StartAlarmStreaming(nullptr, from) {}
  inline StartAlarmStreaming(StartAlarmStreaming&& from) noexcept : StartAlarmStreaming(nullptr, ::std::move(from)) {}
  inline StartAlarmStreaming& operator=(const StartAlarmStreaming& from) {
    CopyFrom(from);
    return *this;
  }
  inline StartAlarmStreaming& operator=(StartAlarmStreaming&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const StartAlarmStreaming& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<StartAlarmStreaming>(&StartAlarmStreaming_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(StartAlarmStreaming& a, StartAlarmStreaming& b) { a.Swap(&b); }
  inline void Swap(StartAlarmStreaming* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StartAlarmStreaming* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] StartAlarmStreaming* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<StartAlarmStreaming>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const StartAlarmStreaming& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const StartAlarmStreaming& from) { StartAlarmStreaming::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(StartAlarmStreaming* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.StartAlarmStreaming"; }

  explicit StartAlarmStreaming(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  StartAlarmStreaming(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StartAlarmStreaming& from);
  StartAlarmStreaming(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StartAlarmStreaming&& from) noexcept
      : StartAlarmStreaming(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
    kBatchIdFieldNumber = 2,
    kStartSequnceIdFieldNumber = 3,
    kVersionFieldNumber = 5,
    kResetsFieldNumber = 4,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // uint64 batch_id = 2 [deprecated = true];
  [[deprecated]]  void clear_batch_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t batch_id() const;
  [[deprecated]] void set_batch_id(::uint64_t value);

  private:
  ::uint64_t _internal_batch_id() const;
  void _internal_set_batch_id(::uint64_t value);

  public:
  // uint64 start_sequnce_id = 3 [deprecated = true];
  [[deprecated]]  void clear_start_sequnce_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t start_sequnce_id() const;
  [[deprecated]] void set_start_sequnce_id(::uint64_t value);

  private:
  ::uint64_t _internal_start_sequnce_id() const;
  void _internal_set_start_sequnce_id(::uint64_t value);

  public:
  // uint64 version = 5;
  void clear_version() ;
  [[nodiscard]] ::uint64_t version() const;
  void set_version(::uint64_t value);

  private:
  ::uint64_t _internal_version() const;
  void _internal_set_version(::uint64_t value);

  public:
  // bool resets = 4;
  void clear_resets() ;
  [[nodiscard]] bool resets() const;
  void set_resets(bool value);

  private:
  bool _internal_resets() const;
  void _internal_set_resets(bool value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.StartAlarmStreaming)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          0, 45,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const StartAlarmStreaming& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::uint64_t batch_id_;
    ::uint64_t start_sequnce_id_;
    ::uint64_t version_;
    bool resets_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SendAlarmSnapshot final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.SendAlarmSnapshot) */ {
 public:
  inline SendAlarmSnapshot() : SendAlarmSnapshot(nullptr) {}
  ~SendAlarmSnapshot() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SendAlarmSnapshot* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SendAlarmSnapshot));
  }
#endif

  template <typename = void>
  explicit constexpr SendAlarmSnapshot(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline SendAlarmSnapshot(const SendAlarmSnapshot& from) : SendAlarmSnapshot(nullptr, from) {}
  inline SendAlarmSnapshot(SendAlarmSnapshot&& from) noexcept : SendAlarmSnapshot(nullptr, ::std::move(from)) {}
  inline SendAlarmSnapshot& operator=(const SendAlarmSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline SendAlarmSnapshot& operator=(SendAlarmSnapshot&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const SendAlarmSnapshot& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SendAlarmSnapshot>(&SendAlarmSnapshot_globals_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(SendAlarmSnapshot& a, SendAlarmSnapshot& b) { a.Swap(&b); }
  inline void Swap(SendAlarmSnapshot* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SendAlarmSnapshot* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SendAlarmSnapshot* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SendAlarmSnapshot>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SendAlarmSnapshot& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SendAlarmSnapshot& from) { SendAlarmSnapshot::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SendAlarmSnapshot* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.SendAlarmSnapshot"; }

  explicit SendAlarmSnapshot(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SendAlarmSnapshot(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SendAlarmSnapshot& from);
  SendAlarmSnapshot(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SendAlarmSnapshot&& from) noexcept
      : SendAlarmSnapshot(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
    kClaimIdFieldNumber = 2,
    kSnapshotUuidFieldNumber = 5,
    kSnapshotIdFieldNumber = 3,
    kSequenceIdFieldNumber = 4,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // string claim_id = 2;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // string snapshot_uuid = 5;
  void clear_snapshot_uuid() ;
  [[nodiscard]] const ::std::string& snapshot_uuid() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_snapshot_uuid(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_snapshot_uuid();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_snapshot_uuid();
  void set_allocated_snapshot_uuid(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_snapshot_uuid() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_uuid(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_snapshot_uuid();

  public:
  // uint64 snapshot_id = 3 [deprecated = true];
  [[deprecated]]  void clear_snapshot_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t snapshot_id() const;
  [[deprecated]] void set_snapshot_id(::uint64_t value);

  private:
  ::uint64_t _internal_snapshot_id() const;
  void _internal_set_snapshot_id(::uint64_t value);

  public:
  // uint64 sequence_id = 4 [deprecated = true];
  [[deprecated]]  void clear_sequence_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t sequence_id() const;
  [[deprecated]] void set_sequence_id(::uint64_t value);

  private:
  ::uint64_t _internal_sequence_id() const;
  void _internal_set_sequence_id(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.SendAlarmSnapshot)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          0, 64,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SendAlarmSnapshot& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::google::protobuf::internal::ArenaStringPtr snapshot_uuid_;
    ::uint64_t snapshot_id_;
    ::uint64_t sequence_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SendAlarmLogHealth final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.SendAlarmLogHealth) */ {
 public:
  inline SendAlarmLogHealth() : SendAlarmLogHealth(nullptr) {}
  ~SendAlarmLogHealth() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SendAlarmLogHealth* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SendAlarmLogHealth));
  }
#endif

  template <typename = void>
  explicit constexpr SendAlarmLogHealth(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline SendAlarmLogHealth(const SendAlarmLogHealth& from) : SendAlarmLogHealth(nullptr, from) {}
  inline SendAlarmLogHealth(SendAlarmLogHealth&& from) noexcept : SendAlarmLogHealth(nullptr, ::std::move(from)) {}
  inline SendAlarmLogHealth& operator=(const SendAlarmLogHealth& from) {
    CopyFrom(from);
    return *this;
  }
  inline SendAlarmLogHealth& operator=(SendAlarmLogHealth&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const SendAlarmLogHealth& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SendAlarmLogHealth>(&SendAlarmLogHealth_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(SendAlarmLogHealth& a, SendAlarmLogHealth& b) { a.Swap(&b); }
  inline void Swap(SendAlarmLogHealth* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SendAlarmLogHealth* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SendAlarmLogHealth* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SendAlarmLogHealth>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SendAlarmLogHealth& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SendAlarmLogHealth& from) { SendAlarmLogHealth::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SendAlarmLogHealth* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.SendAlarmLogHealth"; }

  explicit SendAlarmLogHealth(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SendAlarmLogHealth(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SendAlarmLogHealth& from);
  SendAlarmLogHealth(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SendAlarmLogHealth&& from) noexcept
      : SendAlarmLogHealth(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.SendAlarmLogHealth)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 44,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SendAlarmLogHealth& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SendAlarmCheckpoint final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.SendAlarmCheckpoint) */ {
 public:
  inline SendAlarmCheckpoint() : SendAlarmCheckpoint(nullptr) {}
  ~SendAlarmCheckpoint() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SendAlarmCheckpoint* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SendAlarmCheckpoint));
  }
#endif

  template <typename = void>
  explicit constexpr SendAlarmCheckpoint(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline SendAlarmCheckpoint(const SendAlarmCheckpoint& from) : SendAlarmCheckpoint(nullptr, from) {}
  inline SendAlarmCheckpoint(SendAlarmCheckpoint&& from) noexcept : SendAlarmCheckpoint(nullptr, ::std::move(from)) {}
  inline SendAlarmCheckpoint& operator=(const SendAlarmCheckpoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline SendAlarmCheckpoint& operator=(SendAlarmCheckpoint&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const SendAlarmCheckpoint& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SendAlarmCheckpoint>(&SendAlarmCheckpoint_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(SendAlarmCheckpoint& a, SendAlarmCheckpoint& b) { a.Swap(&b); }
  inline void Swap(SendAlarmCheckpoint* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SendAlarmCheckpoint* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SendAlarmCheckpoint* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SendAlarmCheckpoint>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SendAlarmCheckpoint& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SendAlarmCheckpoint& from) { SendAlarmCheckpoint::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SendAlarmCheckpoint* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.SendAlarmCheckpoint"; }

  explicit SendAlarmCheckpoint(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SendAlarmCheckpoint(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SendAlarmCheckpoint& from);
  SendAlarmCheckpoint(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SendAlarmCheckpoint&& from) noexcept
      : SendAlarmCheckpoint(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
    kClaimIdFieldNumber = 2,
    kVersionFieldNumber = 3,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // string claim_id = 2;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // uint64 version = 3;
  void clear_version() ;
  [[nodiscard]] ::uint64_t version() const;
  void set_version(::uint64_t value);

  private:
  ::uint64_t _internal_version() const;
  void _internal_set_version(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.SendAlarmCheckpoint)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 53,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SendAlarmCheckpoint& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::uint64_t version_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AlarmLogEntry final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.AlarmLogEntry) */ {
 public:
  inline AlarmLogEntry() : AlarmLogEntry(nullptr) {}
  ~AlarmLogEntry() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AlarmLogEntry* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AlarmLogEntry));
  }
#endif

  template <typename = void>
  explicit constexpr AlarmLogEntry(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline AlarmLogEntry(const AlarmLogEntry& from) : AlarmLogEntry(nullptr, from) {}
  inline AlarmLogEntry(AlarmLogEntry&& from) noexcept : AlarmLogEntry(nullptr, ::std::move(from)) {}
  inline AlarmLogEntry& operator=(const AlarmLogEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmLogEntry& operator=(AlarmLogEntry&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const AlarmLogEntry& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AlarmLogEntry>(&AlarmLogEntry_globals_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(AlarmLogEntry& a, AlarmLogEntry& b) { a.Swap(&b); }
  inline void Swap(AlarmLogEntry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlarmLogEntry* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AlarmLogEntry* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AlarmLogEntry>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlarmLogEntry& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AlarmLogEntry& from) { AlarmLogEntry::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AlarmLogEntry* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.AlarmLogEntry"; }

  explicit AlarmLogEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AlarmLogEntry(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AlarmLogEntry& from);
  AlarmLogEntry(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AlarmLogEntry&& from) noexcept
      : AlarmLogEntry(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
    kClaimIdFieldNumber = 2,
    kChartFieldNumber = 3,
    kNameFieldNumber = 4,
    kFamilyFieldNumber = 5,
    kConfigHashFieldNumber = 9,
    kTimezoneFieldNumber = 11,
    kExecPathFieldNumber = 12,
    kConfSourceFieldNumber = 13,
    kCommandFieldNumber = 14,
    kValueStringFieldNumber = 23,
    kOldValueStringFieldNumber = 24,
    kRenderedInfoFieldNumber = 28,
    kChartContextFieldNumber = 29,
    kTransitionIdFieldNumber = 31,
    kBatchIdFieldNumber = 6,
    kSequenceIdFieldNumber = 7,
    kWhenFieldNumber = 8,
    kUtcOffsetFieldNumber = 10,
    kDurationFieldNumber = 15,
    kNonClearDurationFieldNumber = 16,
    kStatusFieldNumber = 17,
    kDelayFieldNumber = 19,
    kDelayUpToTimestampFieldNumber = 20,
    kLastRepeatFieldNumber = 21,
    kOldStatusFieldNumber = 18,
    kSilencedFieldNumber = 22,
    kUpdatedFieldNumber = 27,
    kValueFieldNumber = 25,
    kOldValueFieldNumber = 26,
    kEventIdFieldNumber = 30,
    kChartNameFieldNumber = 32,
    kSummaryFieldNumber = 33,
    kAlertVersionFieldNumber = 34,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // string claim_id = 2;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // string chart = 3;
  void clear_chart() ;
  [[nodiscard]] const ::std::string& chart() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_chart(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_chart();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_chart();
  void set_allocated_chart(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_chart() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_chart(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_chart();

  public:
  // string name = 4;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

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

  public:
  // string family = 5 [deprecated = true];
  [[deprecated]]  void clear_family() ;
  [[nodiscard]] [[deprecated]] const ::std::string& family() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  [[deprecated]] void set_family(Arg_&& arg, Args_... args);
  [[deprecated]] ::std::string* PROTOBUF_NONNULL mutable_family();
  [[deprecated]] [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_family();
  [[deprecated]] void set_allocated_family(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_family() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_family(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_family();

  public:
  // string config_hash = 9;
  void clear_config_hash() ;
  [[nodiscard]] const ::std::string& config_hash() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_config_hash(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_config_hash();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_config_hash();
  void set_allocated_config_hash(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_config_hash() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_config_hash(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_config_hash();

  public:
  // string timezone = 11;
  void clear_timezone() ;
  [[nodiscard]] const ::std::string& timezone() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_timezone(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_timezone();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_timezone();
  void set_allocated_timezone(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_timezone() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_timezone(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_timezone();

  public:
  // string exec_path = 12;
  void clear_exec_path() ;
  [[nodiscard]] const ::std::string& exec_path() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_exec_path(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_exec_path();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_exec_path();
  void set_allocated_exec_path(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_exec_path() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_exec_path(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_exec_path();

  public:
  // string conf_source = 13;
  void clear_conf_source() ;
  [[nodiscard]] const ::std::string& conf_source() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_conf_source(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_conf_source();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_conf_source();
  void set_allocated_conf_source(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_conf_source() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_conf_source(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_conf_source();

  public:
  // string command = 14;
  void clear_command() ;
  [[nodiscard]] const ::std::string& command() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_command(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_command();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_command();
  void set_allocated_command(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_command() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_command(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_command();

  public:
  // string value_string = 23;
  void clear_value_string() ;
  [[nodiscard]] const ::std::string& value_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_value_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_value_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_value_string();
  void set_allocated_value_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_value_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_value_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_value_string();

  public:
  // string old_value_string = 24;
  void clear_old_value_string() ;
  [[nodiscard]] const ::std::string& old_value_string() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_old_value_string(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_old_value_string();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_old_value_string();
  void set_allocated_old_value_string(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_old_value_string() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_old_value_string(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_old_value_string();

  public:
  // string rendered_info = 28;
  void clear_rendered_info() ;
  [[nodiscard]] const ::std::string& rendered_info() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_rendered_info(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_rendered_info();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_rendered_info();
  void set_allocated_rendered_info(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_rendered_info() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_rendered_info(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_rendered_info();

  public:
  // string chart_context = 29;
  void clear_chart_context() ;
  [[nodiscard]] const ::std::string& chart_context() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_chart_context(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_chart_context();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_chart_context();
  void set_allocated_chart_context(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_chart_context() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_chart_context(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_chart_context();

  public:
  // string transition_id = 31;
  void clear_transition_id() ;
  [[nodiscard]] const ::std::string& transition_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_transition_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_transition_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_transition_id();
  void set_allocated_transition_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_transition_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_transition_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_transition_id();

  public:
  // uint64 batch_id = 6 [deprecated = true];
  [[deprecated]]  void clear_batch_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t batch_id() const;
  [[deprecated]] void set_batch_id(::uint64_t value);

  private:
  ::uint64_t _internal_batch_id() const;
  void _internal_set_batch_id(::uint64_t value);

  public:
  // uint64 sequence_id = 7 [deprecated = true];
  [[deprecated]]  void clear_sequence_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t sequence_id() const;
  [[deprecated]] void set_sequence_id(::uint64_t value);

  private:
  ::uint64_t _internal_sequence_id() const;
  void _internal_set_sequence_id(::uint64_t value);

  public:
  // uint64 when = 8;
  void clear_when() ;
  [[nodiscard]] ::uint64_t when() const;
  void set_when(::uint64_t value);

  private:
  ::uint64_t _internal_when() const;
  void _internal_set_when(::uint64_t value);

  public:
  // int32 utc_offset = 10;
  void clear_utc_offset() ;
  [[nodiscard]] ::int32_t utc_offset() const;
  void set_utc_offset(::int32_t value);

  private:
  ::int32_t _internal_utc_offset() const;
  void _internal_set_utc_offset(::int32_t value);

  public:
  // uint32 duration = 15;
  void clear_duration() ;
  [[nodiscard]] ::uint32_t duration() const;
  void set_duration(::uint32_t value);

  private:
  ::uint32_t _internal_duration() const;
  void _internal_set_duration(::uint32_t value);

  public:
  // uint32 non_clear_duration = 16;
  void clear_non_clear_duration() ;
  [[nodiscard]] ::uint32_t non_clear_duration() const;
  void set_non_clear_duration(::uint32_t value);

  private:
  ::uint32_t _internal_non_clear_duration() const;
  void _internal_set_non_clear_duration(::uint32_t value);

  public:
  // .alarms.v1.AlarmStatus status = 17;
  void clear_status() ;
  [[nodiscard]] ::alarms::v1::AlarmStatus status() const;
  void set_status(::alarms::v1::AlarmStatus value);

  private:
  ::alarms::v1::AlarmStatus _internal_status() const;
  void _internal_set_status(::alarms::v1::AlarmStatus value);

  public:
  // uint64 delay = 19;
  void clear_delay() ;
  [[nodiscard]] ::uint64_t delay() const;
  void set_delay(::uint64_t value);

  private:
  ::uint64_t _internal_delay() const;
  void _internal_set_delay(::uint64_t value);

  public:
  // uint64 delay_up_to_timestamp = 20;
  void clear_delay_up_to_timestamp() ;
  [[nodiscard]] ::uint64_t delay_up_to_timestamp() const;
  void set_delay_up_to_timestamp(::uint64_t value);

  private:
  ::uint64_t _internal_delay_up_to_timestamp() const;
  void _internal_set_delay_up_to_timestamp(::uint64_t value);

  public:
  // uint64 last_repeat = 21;
  void clear_last_repeat() ;
  [[nodiscard]] ::uint64_t last_repeat() const;
  void set_last_repeat(::uint64_t value);

  private:
  ::uint64_t _internal_last_repeat() const;
  void _internal_set_last_repeat(::uint64_t value);

  public:
  // .alarms.v1.AlarmStatus old_status = 18;
  void clear_old_status() ;
  [[nodiscard]] ::alarms::v1::AlarmStatus old_status() const;
  void set_old_status(::alarms::v1::AlarmStatus value);

  private:
  ::alarms::v1::AlarmStatus _internal_old_status() const;
  void _internal_set_old_status(::alarms::v1::AlarmStatus value);

  public:
  // bool silenced = 22;
  void clear_silenced() ;
  [[nodiscard]] bool silenced() const;
  void set_silenced(bool value);

  private:
  bool _internal_silenced() const;
  void _internal_set_silenced(bool value);

  public:
  // bool updated = 27;
  void clear_updated() ;
  [[nodiscard]] bool updated() const;
  void set_updated(bool value);

  private:
  bool _internal_updated() const;
  void _internal_set_updated(bool value);

  public:
  // double value = 25;
  void clear_value() ;
  [[nodiscard]] double value() const;
  void set_value(double value);

  private:
  double _internal_value() const;
  void _internal_set_value(double value);

  public:
  // double old_value = 26;
  void clear_old_value() ;
  [[nodiscard]] double old_value() const;
  void set_old_value(double value);

  private:
  double _internal_old_value() const;
  void _internal_set_old_value(double value);

  public:
  // uint64 event_id = 30;
  void clear_event_id() ;
  [[nodiscard]] ::uint64_t event_id() const;
  void set_event_id(::uint64_t value);

  private:
  ::uint64_t _internal_event_id() const;
  void _internal_set_event_id(::uint64_t value);

  public:
  // string chart_name = 32;
  void clear_chart_name() ;
  [[nodiscard]] const ::std::string& chart_name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_chart_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_chart_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_chart_name();
  void set_allocated_chart_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_chart_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_chart_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_chart_name();

  public:
  // string summary = 33;
  void clear_summary() ;
  [[nodiscard]] const ::std::string& summary() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_summary(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_summary();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_summary();
  void set_allocated_summary(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_summary() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_summary(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_summary();

  public:
  // uint64 alert_version = 34;
  void clear_alert_version() ;
  [[nodiscard]] ::uint64_t alert_version() const;
  void set_alert_version(::uint64_t value);

  private:
  ::uint64_t _internal_alert_version() const;
  void _internal_set_alert_version(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.AlarmLogEntry)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 34,
                          0, 224,
                          7>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AlarmLogEntry& from_msg);
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::google::protobuf::internal::ArenaStringPtr chart_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr family_;
    ::google::protobuf::internal::ArenaStringPtr config_hash_;
    ::google::protobuf::internal::ArenaStringPtr timezone_;
    ::google::protobuf::internal::ArenaStringPtr exec_path_;
    ::google::protobuf::internal::ArenaStringPtr conf_source_;
    ::google::protobuf::internal::ArenaStringPtr command_;
    ::google::protobuf::internal::ArenaStringPtr value_string_;
    ::google::protobuf::internal::ArenaStringPtr old_value_string_;
    ::google::protobuf::internal::ArenaStringPtr rendered_info_;
    ::google::protobuf::internal::ArenaStringPtr chart_context_;
    ::google::protobuf::internal::ArenaStringPtr transition_id_;
    ::uint64_t batch_id_;
    ::uint64_t sequence_id_;
    ::uint64_t when_;
    ::int32_t utc_offset_;
    ::uint32_t duration_;
    ::uint32_t non_clear_duration_;
    int status_;
    ::uint64_t delay_;
    ::uint64_t delay_up_to_timestamp_;
    ::uint64_t last_repeat_;
    int old_status_;
    bool silenced_;
    bool updated_;
    double value_;
    double old_value_;
    ::uint64_t event_id_;
    ::google::protobuf::internal::ArenaStringPtr chart_name_;
    ::google::protobuf::internal::ArenaStringPtr summary_;
    ::uint64_t alert_version_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AlarmCheckpoint final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.AlarmCheckpoint) */ {
 public:
  inline AlarmCheckpoint() : AlarmCheckpoint(nullptr) {}
  ~AlarmCheckpoint() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AlarmCheckpoint* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AlarmCheckpoint));
  }
#endif

  template <typename = void>
  explicit constexpr AlarmCheckpoint(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline AlarmCheckpoint(const AlarmCheckpoint& from) : AlarmCheckpoint(nullptr, from) {}
  inline AlarmCheckpoint(AlarmCheckpoint&& from) noexcept : AlarmCheckpoint(nullptr, ::std::move(from)) {}
  inline AlarmCheckpoint& operator=(const AlarmCheckpoint& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmCheckpoint& operator=(AlarmCheckpoint&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const AlarmCheckpoint& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AlarmCheckpoint>(&AlarmCheckpoint_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(AlarmCheckpoint& a, AlarmCheckpoint& b) { a.Swap(&b); }
  inline void Swap(AlarmCheckpoint* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlarmCheckpoint* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AlarmCheckpoint* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AlarmCheckpoint>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlarmCheckpoint& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AlarmCheckpoint& from) { AlarmCheckpoint::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AlarmCheckpoint* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.AlarmCheckpoint"; }

  explicit AlarmCheckpoint(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AlarmCheckpoint(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AlarmCheckpoint& from);
  AlarmCheckpoint(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AlarmCheckpoint&& from) noexcept
      : AlarmCheckpoint(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNodeIdFieldNumber = 1,
    kClaimIdFieldNumber = 2,
    kChecksumFieldNumber = 3,
  };
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // string claim_id = 2;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // bytes checksum = 3;
  void clear_checksum() ;
  [[nodiscard]] const ::std::string& checksum() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_checksum(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_checksum();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_checksum();
  void set_allocated_checksum(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_checksum() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_checksum(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_checksum();

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.AlarmCheckpoint)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          0, 49,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AlarmCheckpoint& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::google::protobuf::internal::ArenaStringPtr checksum_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED LogEntries final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.LogEntries) */ {
 public:
  inline LogEntries() : LogEntries(nullptr) {}
  ~LogEntries() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(LogEntries* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(LogEntries));
  }
#endif

  template <typename = void>
  explicit constexpr LogEntries(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline LogEntries(const LogEntries& from) : LogEntries(nullptr, from) {}
  inline LogEntries(LogEntries&& from) noexcept : LogEntries(nullptr, ::std::move(from)) {}
  inline LogEntries& operator=(const LogEntries& from) {
    CopyFrom(from);
    return *this;
  }
  inline LogEntries& operator=(LogEntries&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const LogEntries& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<LogEntries>(&LogEntries_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(LogEntries& a, LogEntries& b) { a.Swap(&b); }
  inline void Swap(LogEntries* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LogEntries* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] LogEntries* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<LogEntries>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const LogEntries& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const LogEntries& from) { LogEntries::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(LogEntries* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.LogEntries"; }

  explicit LogEntries(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  LogEntries(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const LogEntries& from);
  LogEntries(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, LogEntries&& from) noexcept
      : LogEntries(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFirstWhenFieldNumber = 2,
    kLastWhenFieldNumber = 4,
    kFirstSequenceIdFieldNumber = 1,
    kLastSequenceIdFieldNumber = 3,
  };
  // .google.protobuf.Timestamp first_when = 2;
  [[nodiscard]] bool has_first_when()
      const;
  void clear_first_when() ;
  [[nodiscard]] const ::google::protobuf::Timestamp& first_when() const;
  [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_first_when();
  ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_first_when();
  void set_allocated_first_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_first_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value);
  ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_first_when();

  private:
  const ::google::protobuf::Timestamp& _internal_first_when() const;
  ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_first_when();

  public:
  // .google.protobuf.Timestamp last_when = 4;
  [[nodiscard]] bool has_last_when()
      const;
  void clear_last_when() ;
  [[nodiscard]] const ::google::protobuf::Timestamp& last_when() const;
  [[nodiscard]] ::google::protobuf::Timestamp* PROTOBUF_NULLABLE release_last_when();
  ::google::protobuf::Timestamp* PROTOBUF_NONNULL mutable_last_when();
  void set_allocated_last_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_last_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value);
  ::google::protobuf::Timestamp* PROTOBUF_NULLABLE unsafe_arena_release_last_when();

  private:
  const ::google::protobuf::Timestamp& _internal_last_when() const;
  ::google::protobuf::Timestamp* PROTOBUF_NONNULL _internal_mutable_last_when();

  public:
  // int64 first_sequence_id = 1;
  void clear_first_sequence_id() ;
  [[nodiscard]] ::int64_t first_sequence_id() const;
  void set_first_sequence_id(::int64_t value);

  private:
  ::int64_t _internal_first_sequence_id() const;
  void _internal_set_first_sequence_id(::int64_t value);

  public:
  // int64 last_sequence_id = 3;
  void clear_last_sequence_id() ;
  [[nodiscard]] ::int64_t last_sequence_id() const;
  void set_last_sequence_id(::int64_t value);

  private:
  ::int64_t _internal_last_sequence_id() const;
  void _internal_set_last_sequence_id(::int64_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.LogEntries)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 4,
                          2, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const LogEntries& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::Timestamp* PROTOBUF_NULLABLE first_when_;
    ::google::protobuf::Timestamp* PROTOBUF_NULLABLE last_when_;
    ::int64_t first_sequence_id_;
    ::int64_t last_sequence_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AlarmSnapshot final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.AlarmSnapshot) */ {
 public:
  inline AlarmSnapshot() : AlarmSnapshot(nullptr) {}
  ~AlarmSnapshot() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AlarmSnapshot* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AlarmSnapshot));
  }
#endif

  template <typename = void>
  explicit constexpr AlarmSnapshot(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline AlarmSnapshot(const AlarmSnapshot& from) : AlarmSnapshot(nullptr, from) {}
  inline AlarmSnapshot(AlarmSnapshot&& from) noexcept : AlarmSnapshot(nullptr, ::std::move(from)) {}
  inline AlarmSnapshot& operator=(const AlarmSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmSnapshot& operator=(AlarmSnapshot&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const AlarmSnapshot& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AlarmSnapshot>(&AlarmSnapshot_globals_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(AlarmSnapshot& a, AlarmSnapshot& b) { a.Swap(&b); }
  inline void Swap(AlarmSnapshot* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlarmSnapshot* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AlarmSnapshot* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AlarmSnapshot>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlarmSnapshot& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AlarmSnapshot& from) { AlarmSnapshot::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AlarmSnapshot* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.AlarmSnapshot"; }

  explicit AlarmSnapshot(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AlarmSnapshot(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AlarmSnapshot& from);
  AlarmSnapshot(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AlarmSnapshot&& from) noexcept
      : AlarmSnapshot(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kAlarmsFieldNumber = 7,
    kNodeIdFieldNumber = 1,
    kClaimIdFieldNumber = 2,
    kSnapshotUuidFieldNumber = 8,
    kSnapshotIdFieldNumber = 3,
    kChunksFieldNumber = 4,
    kChunkSizeFieldNumber = 5,
    kChunkFieldNumber = 6,
  };
  // repeated .alarms.v1.AlarmLogEntry alarms = 7;
  [[nodiscard]] int alarms_size()
      const;
  private:
  int _internal_alarms_size() const;

  public:
  void clear_alarms() ;
  [[nodiscard]] const ::alarms::v1::AlarmLogEntry& alarms(int index) const;
  [[nodiscard]] ::alarms::v1::AlarmLogEntry* PROTOBUF_NONNULL mutable_alarms(int index);
  ::alarms::v1::AlarmLogEntry* PROTOBUF_NONNULL add_alarms();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>&
  alarms() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>* PROTOBUF_NONNULL
  mutable_alarms();

  private:
  const ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>& _internal_alarms() const;
  ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>* PROTOBUF_NONNULL _internal_mutable_alarms();

  public:
  // string node_id = 1;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // string claim_id = 2;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // string snapshot_uuid = 8;
  void clear_snapshot_uuid() ;
  [[nodiscard]] const ::std::string& snapshot_uuid() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_snapshot_uuid(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_snapshot_uuid();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_snapshot_uuid();
  void set_allocated_snapshot_uuid(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_snapshot_uuid() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_snapshot_uuid(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_snapshot_uuid();

  public:
  // uint64 snapshot_id = 3 [deprecated = true];
  [[deprecated]]  void clear_snapshot_id() ;
  [[nodiscard]] [[deprecated]] ::uint64_t snapshot_id() const;
  [[deprecated]] void set_snapshot_id(::uint64_t value);

  private:
  ::uint64_t _internal_snapshot_id() const;
  void _internal_set_snapshot_id(::uint64_t value);

  public:
  // uint32 chunks = 4;
  void clear_chunks() ;
  [[nodiscard]] ::uint32_t chunks() const;
  void set_chunks(::uint32_t value);

  private:
  ::uint32_t _internal_chunks() const;
  void _internal_set_chunks(::uint32_t value);

  public:
  // uint32 chunk_size = 5;
  void clear_chunk_size() ;
  [[nodiscard]] ::uint32_t chunk_size() const;
  void set_chunk_size(::uint32_t value);

  private:
  ::uint32_t _internal_chunk_size() const;
  void _internal_set_chunk_size(::uint32_t value);

  public:
  // uint32 chunk = 6;
  void clear_chunk() ;
  [[nodiscard]] ::uint32_t chunk() const;
  void set_chunk(::uint32_t value);

  private:
  ::uint32_t _internal_chunk() const;
  void _internal_set_chunk(::uint32_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.AlarmSnapshot)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 8,
                          1, 68,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AlarmSnapshot& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::alarms::v1::AlarmLogEntry > alarms_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::google::protobuf::internal::ArenaStringPtr snapshot_uuid_;
    ::uint64_t snapshot_id_;
    ::uint32_t chunks_;
    ::uint32_t chunk_size_;
    ::uint32_t chunk_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED AlarmLogHealth final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:alarms.v1.AlarmLogHealth) */ {
 public:
  inline AlarmLogHealth() : AlarmLogHealth(nullptr) {}
  ~AlarmLogHealth() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(AlarmLogHealth* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(AlarmLogHealth));
  }
#endif

  template <typename = void>
  explicit constexpr AlarmLogHealth(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline AlarmLogHealth(const AlarmLogHealth& from) : AlarmLogHealth(nullptr, from) {}
  inline AlarmLogHealth(AlarmLogHealth&& from) noexcept : AlarmLogHealth(nullptr, ::std::move(from)) {}
  inline AlarmLogHealth& operator=(const AlarmLogHealth& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmLogHealth& operator=(AlarmLogHealth&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  [[nodiscard]] inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }

  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  [[nodiscard]] static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL
  GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  [[nodiscard]] static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  [[nodiscard]] static const AlarmLogHealth& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AlarmLogHealth>(&AlarmLogHealth_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(AlarmLogHealth& a, AlarmLogHealth& b) { a.Swap(&b); }
  inline void Swap(AlarmLogHealth* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AlarmLogHealth* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AlarmLogHealth* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AlarmLogHealth>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlarmLogHealth& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AlarmLogHealth& from) { AlarmLogHealth::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(AlarmLogHealth* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.AlarmLogHealth"; }

  explicit AlarmLogHealth(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AlarmLogHealth(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AlarmLogHealth& from);
  AlarmLogHealth(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AlarmLogHealth&& from) noexcept
      : AlarmLogHealth(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  [[nodiscard]] ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kClaimIdFieldNumber = 1,
    kNodeIdFieldNumber = 2,
    kLogEntriesFieldNumber = 5,
    kEnabledFieldNumber = 3,
    kStatusFieldNumber = 4,
  };
  // string claim_id = 1;
  void clear_claim_id() ;
  [[nodiscard]] const ::std::string& claim_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_claim_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_claim_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_claim_id();
  void set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_claim_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_claim_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_claim_id();

  public:
  // string node_id = 2;
  void clear_node_id() ;
  [[nodiscard]] const ::std::string& node_id() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_node_id(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_node_id();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_node_id();
  void set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_node_id() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_node_id(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_node_id();

  public:
  // .alarms.v1.LogEntries log_entries = 5;
  [[nodiscard]] bool has_log_entries()
      const;
  void clear_log_entries() ;
  [[nodiscard]] const ::alarms::v1::LogEntries& log_entries() const;
  [[nodiscard]] ::alarms::v1::LogEntries* PROTOBUF_NULLABLE release_log_entries();
  ::alarms::v1::LogEntries* PROTOBUF_NONNULL mutable_log_entries();
  void set_allocated_log_entries(::alarms::v1::LogEntries* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_log_entries(::alarms::v1::LogEntries* PROTOBUF_NULLABLE value);
  ::alarms::v1::LogEntries* PROTOBUF_NULLABLE unsafe_arena_release_log_entries();

  private:
  const ::alarms::v1::LogEntries& _internal_log_entries() const;
  ::alarms::v1::LogEntries* PROTOBUF_NONNULL _internal_mutable_log_entries();

  public:
  // bool enabled = 3;
  void clear_enabled() ;
  [[nodiscard]] bool enabled() const;
  void set_enabled(bool value);

  private:
  bool _internal_enabled() const;
  void _internal_set_enabled(bool value);

  public:
  // .alarms.v1.AlarmLogStatus status = 4;
  void clear_status() ;
  [[nodiscard]] ::alarms::v1::AlarmLogStatus status() const;
  void set_status(::alarms::v1::AlarmLogStatus value);

  private:
  ::alarms::v1::AlarmLogStatus _internal_status() const;
  void _internal_set_status(::alarms::v1::AlarmLogStatus value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.AlarmLogHealth)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          1, 48,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const AlarmLogHealth& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr claim_id_;
    ::google::protobuf::internal::ArenaStringPtr node_id_;
    ::alarms::v1::LogEntries* PROTOBUF_NULLABLE log_entries_;
    bool enabled_;
    int status_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proto_2falarm_2fv1_2fstream_2eproto;
};

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




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


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

// SendAlarmLogHealth

// string node_id = 1;
inline void SendAlarmLogHealth::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& SendAlarmLogHealth::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmLogHealth.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmLogHealth::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmLogHealth.node_id)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmLogHealth::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmLogHealth.node_id)
  return _s;
}
inline const ::std::string& SendAlarmLogHealth::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void SendAlarmLogHealth::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmLogHealth::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmLogHealth::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmLogHealth.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmLogHealth::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmLogHealth.node_id)
}

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

// AlarmLogHealth

// string claim_id = 1;
inline void AlarmLogHealth::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& AlarmLogHealth::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogHealth.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogHealth::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogHealth.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogHealth::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogHealth.claim_id)
  return _s;
}
inline const ::std::string& AlarmLogHealth::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void AlarmLogHealth::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogHealth::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogHealth::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogHealth.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogHealth::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogHealth.claim_id)
}

// string node_id = 2;
inline void AlarmLogHealth::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& AlarmLogHealth::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogHealth.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogHealth::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogHealth.node_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogHealth::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogHealth.node_id)
  return _s;
}
inline const ::std::string& AlarmLogHealth::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void AlarmLogHealth::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogHealth::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogHealth::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogHealth.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogHealth::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogHealth.node_id)
}

// bool enabled = 3;
inline void AlarmLogHealth::clear_enabled() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enabled_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool AlarmLogHealth::enabled() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogHealth.enabled)
  return _internal_enabled();
}
inline void AlarmLogHealth::set_enabled(bool value) {
  _internal_set_enabled(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogHealth.enabled)
}
inline bool AlarmLogHealth::_internal_enabled() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enabled_;
}
inline void AlarmLogHealth::_internal_set_enabled(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enabled_ = value;
}

// .alarms.v1.AlarmLogStatus status = 4;
inline void AlarmLogHealth::clear_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.status_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::alarms::v1::AlarmLogStatus AlarmLogHealth::status() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogHealth.status)
  return _internal_status();
}
inline void AlarmLogHealth::set_status(::alarms::v1::AlarmLogStatus value) {
  _internal_set_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogHealth.status)
}
inline ::alarms::v1::AlarmLogStatus AlarmLogHealth::_internal_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::alarms::v1::AlarmLogStatus>(_impl_.status_);
}
inline void AlarmLogHealth::_internal_set_status(::alarms::v1::AlarmLogStatus value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.status_ = value;
}

// .alarms.v1.LogEntries log_entries = 5;
inline bool AlarmLogHealth::has_log_entries() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.log_entries_ != nullptr);
  return value;
}
inline void AlarmLogHealth::clear_log_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.log_entries_ != nullptr) _impl_.log_entries_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::alarms::v1::LogEntries& AlarmLogHealth::_internal_log_entries() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::alarms::v1::LogEntries* p = _impl_.log_entries_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::alarms::v1::LogEntries>(&::alarms::v1::LogEntries_globals_);
}
inline const ::alarms::v1::LogEntries& AlarmLogHealth::log_entries() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogHealth.log_entries)
  return _internal_log_entries();
}
inline void AlarmLogHealth::unsafe_arena_set_allocated_log_entries(
    ::alarms::v1::LogEntries* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.log_entries_);
  }
  _impl_.log_entries_ = reinterpret_cast<::alarms::v1::LogEntries*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:alarms.v1.AlarmLogHealth.log_entries)
}
inline ::alarms::v1::LogEntries* PROTOBUF_NULLABLE AlarmLogHealth::release_log_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::alarms::v1::LogEntries* released = _impl_.log_entries_;
  _impl_.log_entries_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::alarms::v1::LogEntries* PROTOBUF_NULLABLE AlarmLogHealth::unsafe_arena_release_log_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogHealth.log_entries)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::alarms::v1::LogEntries* temp = _impl_.log_entries_;
  _impl_.log_entries_ = nullptr;
  return temp;
}
inline ::alarms::v1::LogEntries* PROTOBUF_NONNULL AlarmLogHealth::_internal_mutable_log_entries() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.log_entries_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::alarms::v1::LogEntries>(GetArena());
    _impl_.log_entries_ = reinterpret_cast<::alarms::v1::LogEntries*>(p);
  }
  return _impl_.log_entries_;
}
inline ::alarms::v1::LogEntries* PROTOBUF_NONNULL AlarmLogHealth::mutable_log_entries()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::alarms::v1::LogEntries* _msg = _internal_mutable_log_entries();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogHealth.log_entries)
  return _msg;
}
inline void AlarmLogHealth::set_allocated_log_entries(::alarms::v1::LogEntries* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.log_entries_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.log_entries_ = reinterpret_cast<::alarms::v1::LogEntries*>(value);
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogHealth.log_entries)
}

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

// LogEntries

// int64 first_sequence_id = 1;
inline void LogEntries::clear_first_sequence_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.first_sequence_id_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::int64_t LogEntries::first_sequence_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.LogEntries.first_sequence_id)
  return _internal_first_sequence_id();
}
inline void LogEntries::set_first_sequence_id(::int64_t value) {
  _internal_set_first_sequence_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:alarms.v1.LogEntries.first_sequence_id)
}
inline ::int64_t LogEntries::_internal_first_sequence_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.first_sequence_id_;
}
inline void LogEntries::_internal_set_first_sequence_id(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.first_sequence_id_ = value;
}

// .google.protobuf.Timestamp first_when = 2;
inline bool LogEntries::has_first_when() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.first_when_ != nullptr);
  return value;
}
inline const ::google::protobuf::Timestamp& LogEntries::_internal_first_when() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::google::protobuf::Timestamp* p = _impl_.first_when_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Timestamp>(&::google::protobuf::Timestamp_globals_);
}
inline const ::google::protobuf::Timestamp& LogEntries::first_when() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.LogEntries.first_when)
  return _internal_first_when();
}
inline void LogEntries::unsafe_arena_set_allocated_first_when(
    ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.first_when_);
  }
  _impl_.first_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:alarms.v1.LogEntries.first_when)
}
inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE LogEntries::release_first_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Timestamp* released = _impl_.first_when_;
  _impl_.first_when_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE LogEntries::unsafe_arena_release_first_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.LogEntries.first_when)

  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Timestamp* temp = _impl_.first_when_;
  _impl_.first_when_ = nullptr;
  return temp;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL LogEntries::_internal_mutable_first_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.first_when_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena());
    _impl_.first_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(p);
  }
  return _impl_.first_when_;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL LogEntries::mutable_first_when()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Timestamp* _msg = _internal_mutable_first_when();
  // @@protoc_insertion_point(field_mutable:alarms.v1.LogEntries.first_when)
  return _msg;
}
inline void LogEntries::set_allocated_first_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.first_when_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }

  _impl_.first_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.LogEntries.first_when)
}

// int64 last_sequence_id = 3;
inline void LogEntries::clear_last_sequence_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.last_sequence_id_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::int64_t LogEntries::last_sequence_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.LogEntries.last_sequence_id)
  return _internal_last_sequence_id();
}
inline void LogEntries::set_last_sequence_id(::int64_t value) {
  _internal_set_last_sequence_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:alarms.v1.LogEntries.last_sequence_id)
}
inline ::int64_t LogEntries::_internal_last_sequence_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.last_sequence_id_;
}
inline void LogEntries::_internal_set_last_sequence_id(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.last_sequence_id_ = value;
}

// .google.protobuf.Timestamp last_when = 4;
inline bool LogEntries::has_last_when() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.last_when_ != nullptr);
  return value;
}
inline const ::google::protobuf::Timestamp& LogEntries::_internal_last_when() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::google::protobuf::Timestamp* p = _impl_.last_when_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::google::protobuf::Timestamp>(&::google::protobuf::Timestamp_globals_);
}
inline const ::google::protobuf::Timestamp& LogEntries::last_when() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.LogEntries.last_when)
  return _internal_last_when();
}
inline void LogEntries::unsafe_arena_set_allocated_last_when(
    ::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.last_when_);
  }
  _impl_.last_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:alarms.v1.LogEntries.last_when)
}
inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE LogEntries::release_last_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::google::protobuf::Timestamp* released = _impl_.last_when_;
  _impl_.last_when_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NULLABLE LogEntries::unsafe_arena_release_last_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.LogEntries.last_when)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::google::protobuf::Timestamp* temp = _impl_.last_when_;
  _impl_.last_when_ = nullptr;
  return temp;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL LogEntries::_internal_mutable_last_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.last_when_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Timestamp>(GetArena());
    _impl_.last_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(p);
  }
  return _impl_.last_when_;
}
inline ::google::protobuf::Timestamp* PROTOBUF_NONNULL LogEntries::mutable_last_when()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::google::protobuf::Timestamp* _msg = _internal_mutable_last_when();
  // @@protoc_insertion_point(field_mutable:alarms.v1.LogEntries.last_when)
  return _msg;
}
inline void LogEntries::set_allocated_last_when(::google::protobuf::Timestamp* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.last_when_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.last_when_ = reinterpret_cast<::google::protobuf::Timestamp*>(value);
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.LogEntries.last_when)
}

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

// StartAlarmStreaming

// string node_id = 1;
inline void StartAlarmStreaming::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& StartAlarmStreaming::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.StartAlarmStreaming.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void StartAlarmStreaming::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.StartAlarmStreaming.node_id)
}
inline ::std::string* PROTOBUF_NONNULL StartAlarmStreaming::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.StartAlarmStreaming.node_id)
  return _s;
}
inline const ::std::string& StartAlarmStreaming::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void StartAlarmStreaming::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL StartAlarmStreaming::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE StartAlarmStreaming::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.StartAlarmStreaming.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void StartAlarmStreaming::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.StartAlarmStreaming.node_id)
}

// uint64 batch_id = 2 [deprecated = true];
inline void StartAlarmStreaming::clear_batch_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.batch_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::uint64_t StartAlarmStreaming::batch_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.StartAlarmStreaming.batch_id)
  return _internal_batch_id();
}
inline void StartAlarmStreaming::set_batch_id(::uint64_t value) {
  _internal_set_batch_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:alarms.v1.StartAlarmStreaming.batch_id)
}
inline ::uint64_t StartAlarmStreaming::_internal_batch_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.batch_id_;
}
inline void StartAlarmStreaming::_internal_set_batch_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.batch_id_ = value;
}

// uint64 start_sequnce_id = 3 [deprecated = true];
inline void StartAlarmStreaming::clear_start_sequnce_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.start_sequnce_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t StartAlarmStreaming::start_sequnce_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.StartAlarmStreaming.start_sequnce_id)
  return _internal_start_sequnce_id();
}
inline void StartAlarmStreaming::set_start_sequnce_id(::uint64_t value) {
  _internal_set_start_sequnce_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:alarms.v1.StartAlarmStreaming.start_sequnce_id)
}
inline ::uint64_t StartAlarmStreaming::_internal_start_sequnce_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.start_sequnce_id_;
}
inline void StartAlarmStreaming::_internal_set_start_sequnce_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.start_sequnce_id_ = value;
}

// bool resets = 4;
inline void StartAlarmStreaming::clear_resets() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.resets_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline bool StartAlarmStreaming::resets() const {
  // @@protoc_insertion_point(field_get:alarms.v1.StartAlarmStreaming.resets)
  return _internal_resets();
}
inline void StartAlarmStreaming::set_resets(bool value) {
  _internal_set_resets(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:alarms.v1.StartAlarmStreaming.resets)
}
inline bool StartAlarmStreaming::_internal_resets() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.resets_;
}
inline void StartAlarmStreaming::_internal_set_resets(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.resets_ = value;
}

// uint64 version = 5;
inline void StartAlarmStreaming::clear_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t StartAlarmStreaming::version() const {
  // @@protoc_insertion_point(field_get:alarms.v1.StartAlarmStreaming.version)
  return _internal_version();
}
inline void StartAlarmStreaming::set_version(::uint64_t value) {
  _internal_set_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:alarms.v1.StartAlarmStreaming.version)
}
inline ::uint64_t StartAlarmStreaming::_internal_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.version_;
}
inline void StartAlarmStreaming::_internal_set_version(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = value;
}

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

// SendAlarmCheckpoint

// string node_id = 1;
inline void SendAlarmCheckpoint::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& SendAlarmCheckpoint::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmCheckpoint.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmCheckpoint::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmCheckpoint.node_id)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmCheckpoint::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmCheckpoint.node_id)
  return _s;
}
inline const ::std::string& SendAlarmCheckpoint::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void SendAlarmCheckpoint::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmCheckpoint::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmCheckpoint::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmCheckpoint.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmCheckpoint::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmCheckpoint.node_id)
}

// string claim_id = 2;
inline void SendAlarmCheckpoint::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& SendAlarmCheckpoint::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmCheckpoint.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmCheckpoint::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmCheckpoint.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmCheckpoint::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmCheckpoint.claim_id)
  return _s;
}
inline const ::std::string& SendAlarmCheckpoint::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void SendAlarmCheckpoint::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmCheckpoint::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmCheckpoint::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmCheckpoint.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmCheckpoint::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmCheckpoint.claim_id)
}

// uint64 version = 3;
inline void SendAlarmCheckpoint::clear_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::uint64_t SendAlarmCheckpoint::version() const {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmCheckpoint.version)
  return _internal_version();
}
inline void SendAlarmCheckpoint::set_version(::uint64_t value) {
  _internal_set_version(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmCheckpoint.version)
}
inline ::uint64_t SendAlarmCheckpoint::_internal_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.version_;
}
inline void SendAlarmCheckpoint::_internal_set_version(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.version_ = value;
}

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

// AlarmCheckpoint

// string node_id = 1;
inline void AlarmCheckpoint::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& AlarmCheckpoint::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmCheckpoint.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmCheckpoint::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmCheckpoint.node_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmCheckpoint.node_id)
  return _s;
}
inline const ::std::string& AlarmCheckpoint::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void AlarmCheckpoint::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmCheckpoint::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmCheckpoint.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmCheckpoint::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmCheckpoint.node_id)
}

// string claim_id = 2;
inline void AlarmCheckpoint::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& AlarmCheckpoint::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmCheckpoint.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmCheckpoint::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmCheckpoint.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmCheckpoint.claim_id)
  return _s;
}
inline const ::std::string& AlarmCheckpoint::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void AlarmCheckpoint::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmCheckpoint::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmCheckpoint.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmCheckpoint::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmCheckpoint.claim_id)
}

// bytes checksum = 3;
inline void AlarmCheckpoint::clear_checksum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.checksum_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& AlarmCheckpoint::checksum() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmCheckpoint.checksum)
  return _internal_checksum();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmCheckpoint::set_checksum(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.checksum_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmCheckpoint.checksum)
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::mutable_checksum()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_checksum();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmCheckpoint.checksum)
  return _s;
}
inline const ::std::string& AlarmCheckpoint::_internal_checksum() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.checksum_.Get();
}
inline void AlarmCheckpoint::_internal_set_checksum(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.checksum_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmCheckpoint::_internal_mutable_checksum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.checksum_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmCheckpoint::release_checksum() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmCheckpoint.checksum)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.checksum_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.checksum_.Set("", GetArena());
  }
  return released;
}
inline void AlarmCheckpoint::set_allocated_checksum(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.checksum_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.checksum_.IsDefault()) {
    _impl_.checksum_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmCheckpoint.checksum)
}

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

// AlarmLogEntry

// string node_id = 1;
inline void AlarmLogEntry::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& AlarmLogEntry::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.node_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.node_id)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void AlarmLogEntry::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.node_id)
}

// string claim_id = 2;
inline void AlarmLogEntry::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& AlarmLogEntry::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.claim_id)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void AlarmLogEntry::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.claim_id)
}

// string chart = 3;
inline void AlarmLogEntry::clear_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& AlarmLogEntry::chart() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.chart)
  return _internal_chart();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_chart(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.chart_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.chart)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_chart()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_chart();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.chart)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_chart() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chart_.Get();
}
inline void AlarmLogEntry::_internal_set_chart(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.chart_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.chart)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.chart_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.chart_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_chart(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.chart_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.chart_.IsDefault()) {
    _impl_.chart_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.chart)
}

// string name = 4;
inline void AlarmLogEntry::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& AlarmLogEntry::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.name)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.name)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void AlarmLogEntry::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.name)
}

// string family = 5 [deprecated = true];
inline void AlarmLogEntry::clear_family() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.family_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& AlarmLogEntry::family() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.family)
  return _internal_family();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_family(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.family_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.family)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_family()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_family();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.family)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_family() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.family_.Get();
}
inline void AlarmLogEntry::_internal_set_family(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.family_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_family() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.family_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_family() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.family)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.family_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.family_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_family(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.family_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.family_.IsDefault()) {
    _impl_.family_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.family)
}

// uint64 batch_id = 6 [deprecated = true];
inline void AlarmLogEntry::clear_batch_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.batch_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline ::uint64_t AlarmLogEntry::batch_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.batch_id)
  return _internal_batch_id();
}
inline void AlarmLogEntry::set_batch_id(::uint64_t value) {
  _internal_set_batch_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.batch_id)
}
inline ::uint64_t AlarmLogEntry::_internal_batch_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.batch_id_;
}
inline void AlarmLogEntry::_internal_set_batch_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.batch_id_ = value;
}

// uint64 sequence_id = 7 [deprecated = true];
inline void AlarmLogEntry::clear_sequence_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline ::uint64_t AlarmLogEntry::sequence_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.sequence_id)
  return _internal_sequence_id();
}
inline void AlarmLogEntry::set_sequence_id(::uint64_t value) {
  _internal_set_sequence_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.sequence_id)
}
inline ::uint64_t AlarmLogEntry::_internal_sequence_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sequence_id_;
}
inline void AlarmLogEntry::_internal_set_sequence_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_id_ = value;
}

// uint64 when = 8;
inline void AlarmLogEntry::clear_when() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.when_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline ::uint64_t AlarmLogEntry::when() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.when)
  return _internal_when();
}
inline void AlarmLogEntry::set_when(::uint64_t value) {
  _internal_set_when(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.when)
}
inline ::uint64_t AlarmLogEntry::_internal_when() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.when_;
}
inline void AlarmLogEntry::_internal_set_when(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.when_ = value;
}

// string config_hash = 9;
inline void AlarmLogEntry::clear_config_hash() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.config_hash_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& AlarmLogEntry::config_hash() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.config_hash)
  return _internal_config_hash();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_config_hash(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.config_hash_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.config_hash)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_config_hash()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_config_hash();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.config_hash)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_config_hash() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.config_hash_.Get();
}
inline void AlarmLogEntry::_internal_set_config_hash(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.config_hash_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_config_hash() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.config_hash_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_config_hash() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.config_hash)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.config_hash_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.config_hash_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_config_hash(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.config_hash_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.config_hash_.IsDefault()) {
    _impl_.config_hash_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.config_hash)
}

// int32 utc_offset = 10;
inline void AlarmLogEntry::clear_utc_offset() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.utc_offset_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline ::int32_t AlarmLogEntry::utc_offset() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.utc_offset)
  return _internal_utc_offset();
}
inline void AlarmLogEntry::set_utc_offset(::int32_t value) {
  _internal_set_utc_offset(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.utc_offset)
}
inline ::int32_t AlarmLogEntry::_internal_utc_offset() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.utc_offset_;
}
inline void AlarmLogEntry::_internal_set_utc_offset(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.utc_offset_ = value;
}

// string timezone = 11;
inline void AlarmLogEntry::clear_timezone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.timezone_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& AlarmLogEntry::timezone() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.timezone)
  return _internal_timezone();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_timezone(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.timezone_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.timezone)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_timezone()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_timezone();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.timezone)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_timezone() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.timezone_.Get();
}
inline void AlarmLogEntry::_internal_set_timezone(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.timezone_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_timezone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.timezone_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_timezone() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.timezone)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.timezone_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.timezone_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_timezone(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.timezone_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.timezone_.IsDefault()) {
    _impl_.timezone_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.timezone)
}

// string exec_path = 12;
inline void AlarmLogEntry::clear_exec_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_path_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& AlarmLogEntry::exec_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.exec_path)
  return _internal_exec_path();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_exec_path(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.exec_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.exec_path)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_exec_path()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_exec_path();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.exec_path)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_exec_path() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exec_path_.Get();
}
inline void AlarmLogEntry::_internal_set_exec_path(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_path_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_exec_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.exec_path_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_exec_path() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.exec_path)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.exec_path_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.exec_path_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_exec_path(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.exec_path_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.exec_path_.IsDefault()) {
    _impl_.exec_path_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.exec_path)
}

// string conf_source = 13;
inline void AlarmLogEntry::clear_conf_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.conf_source_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::std::string& AlarmLogEntry::conf_source() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.conf_source)
  return _internal_conf_source();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_conf_source(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.conf_source_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.conf_source)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_conf_source()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_conf_source();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.conf_source)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_conf_source() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.conf_source_.Get();
}
inline void AlarmLogEntry::_internal_set_conf_source(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.conf_source_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_conf_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.conf_source_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_conf_source() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.conf_source)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.conf_source_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.conf_source_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_conf_source(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  _impl_.conf_source_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.conf_source_.IsDefault()) {
    _impl_.conf_source_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.conf_source)
}

// string command = 14;
inline void AlarmLogEntry::clear_command() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.command_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::std::string& AlarmLogEntry::command() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.command)
  return _internal_command();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_command(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.command_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.command)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_command()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_command();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.command)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_command() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.command_.Get();
}
inline void AlarmLogEntry::_internal_set_command(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.command_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_command() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.command_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_command() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.command)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.command_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.command_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_command(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  _impl_.command_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.command_.IsDefault()) {
    _impl_.command_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.command)
}

// uint32 duration = 15;
inline void AlarmLogEntry::clear_duration() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.duration_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline ::uint32_t AlarmLogEntry::duration() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.duration)
  return _internal_duration();
}
inline void AlarmLogEntry::set_duration(::uint32_t value) {
  _internal_set_duration(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.duration)
}
inline ::uint32_t AlarmLogEntry::_internal_duration() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.duration_;
}
inline void AlarmLogEntry::_internal_set_duration(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.duration_ = value;
}

// uint32 non_clear_duration = 16;
inline void AlarmLogEntry::clear_non_clear_duration() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.non_clear_duration_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline ::uint32_t AlarmLogEntry::non_clear_duration() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.non_clear_duration)
  return _internal_non_clear_duration();
}
inline void AlarmLogEntry::set_non_clear_duration(::uint32_t value) {
  _internal_set_non_clear_duration(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.non_clear_duration)
}
inline ::uint32_t AlarmLogEntry::_internal_non_clear_duration() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.non_clear_duration_;
}
inline void AlarmLogEntry::_internal_set_non_clear_duration(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.non_clear_duration_ = value;
}

// .alarms.v1.AlarmStatus status = 17;
inline void AlarmLogEntry::clear_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.status_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline ::alarms::v1::AlarmStatus AlarmLogEntry::status() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.status)
  return _internal_status();
}
inline void AlarmLogEntry::set_status(::alarms::v1::AlarmStatus value) {
  _internal_set_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.status)
}
inline ::alarms::v1::AlarmStatus AlarmLogEntry::_internal_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::alarms::v1::AlarmStatus>(_impl_.status_);
}
inline void AlarmLogEntry::_internal_set_status(::alarms::v1::AlarmStatus value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.status_ = value;
}

// .alarms.v1.AlarmStatus old_status = 18;
inline void AlarmLogEntry::clear_old_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
}
inline ::alarms::v1::AlarmStatus AlarmLogEntry::old_status() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.old_status)
  return _internal_old_status();
}
inline void AlarmLogEntry::set_old_status(::alarms::v1::AlarmStatus value) {
  _internal_set_old_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.old_status)
}
inline ::alarms::v1::AlarmStatus AlarmLogEntry::_internal_old_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::alarms::v1::AlarmStatus>(_impl_.old_status_);
}
inline void AlarmLogEntry::_internal_set_old_status(::alarms::v1::AlarmStatus value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_status_ = value;
}

// uint64 delay = 19;
inline void AlarmLogEntry::clear_delay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline ::uint64_t AlarmLogEntry::delay() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.delay)
  return _internal_delay();
}
inline void AlarmLogEntry::set_delay(::uint64_t value) {
  _internal_set_delay(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.delay)
}
inline ::uint64_t AlarmLogEntry::_internal_delay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.delay_;
}
inline void AlarmLogEntry::_internal_set_delay(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_ = value;
}

// uint64 delay_up_to_timestamp = 20;
inline void AlarmLogEntry::clear_delay_up_to_timestamp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_up_to_timestamp_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline ::uint64_t AlarmLogEntry::delay_up_to_timestamp() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.delay_up_to_timestamp)
  return _internal_delay_up_to_timestamp();
}
inline void AlarmLogEntry::set_delay_up_to_timestamp(::uint64_t value) {
  _internal_set_delay_up_to_timestamp(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.delay_up_to_timestamp)
}
inline ::uint64_t AlarmLogEntry::_internal_delay_up_to_timestamp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.delay_up_to_timestamp_;
}
inline void AlarmLogEntry::_internal_set_delay_up_to_timestamp(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_up_to_timestamp_ = value;
}

// uint64 last_repeat = 21;
inline void AlarmLogEntry::clear_last_repeat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.last_repeat_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline ::uint64_t AlarmLogEntry::last_repeat() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.last_repeat)
  return _internal_last_repeat();
}
inline void AlarmLogEntry::set_last_repeat(::uint64_t value) {
  _internal_set_last_repeat(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.last_repeat)
}
inline ::uint64_t AlarmLogEntry::_internal_last_repeat() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.last_repeat_;
}
inline void AlarmLogEntry::_internal_set_last_repeat(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.last_repeat_ = value;
}

// bool silenced = 22;
inline void AlarmLogEntry::clear_silenced() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.silenced_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
}
inline bool AlarmLogEntry::silenced() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.silenced)
  return _internal_silenced();
}
inline void AlarmLogEntry::set_silenced(bool value) {
  _internal_set_silenced(value);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.silenced)
}
inline bool AlarmLogEntry::_internal_silenced() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.silenced_;
}
inline void AlarmLogEntry::_internal_set_silenced(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.silenced_ = value;
}

// string value_string = 23;
inline void AlarmLogEntry::clear_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::std::string& AlarmLogEntry::value_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.value_string)
  return _internal_value_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_value_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.value_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.value_string)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_value_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_value_string();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.value_string)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_value_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_string_.Get();
}
inline void AlarmLogEntry::_internal_set_value_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.value_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.value_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.value_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.value_string_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_value_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  }
  _impl_.value_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.value_string_.IsDefault()) {
    _impl_.value_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.value_string)
}

// string old_value_string = 24;
inline void AlarmLogEntry::clear_old_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_value_string_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline const ::std::string& AlarmLogEntry::old_value_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.old_value_string)
  return _internal_old_value_string();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_old_value_string(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  _impl_.old_value_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.old_value_string)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_old_value_string()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::std::string* _s = _internal_mutable_old_value_string();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.old_value_string)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_old_value_string() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.old_value_string_.Get();
}
inline void AlarmLogEntry::_internal_set_old_value_string(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_value_string_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_old_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.old_value_string_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_old_value_string() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.old_value_string)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  auto* released = _impl_.old_value_string_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.old_value_string_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_old_value_string(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  }
  _impl_.old_value_string_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.old_value_string_.IsDefault()) {
    _impl_.old_value_string_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.old_value_string)
}

// double value = 25;
inline void AlarmLogEntry::clear_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
}
inline double AlarmLogEntry::value() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.value)
  return _internal_value();
}
inline void AlarmLogEntry::set_value(double value) {
  _internal_set_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.value)
}
inline double AlarmLogEntry::_internal_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.value_;
}
inline void AlarmLogEntry::_internal_set_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.value_ = value;
}

// double old_value = 26;
inline void AlarmLogEntry::clear_old_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_value_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
}
inline double AlarmLogEntry::old_value() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.old_value)
  return _internal_old_value();
}
inline void AlarmLogEntry::set_old_value(double value) {
  _internal_set_old_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.old_value)
}
inline double AlarmLogEntry::_internal_old_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.old_value_;
}
inline void AlarmLogEntry::_internal_set_old_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.old_value_ = value;
}

// bool updated = 27;
inline void AlarmLogEntry::clear_updated() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.updated_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
}
inline bool AlarmLogEntry::updated() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.updated)
  return _internal_updated();
}
inline void AlarmLogEntry::set_updated(bool value) {
  _internal_set_updated(value);
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.updated)
}
inline bool AlarmLogEntry::_internal_updated() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.updated_;
}
inline void AlarmLogEntry::_internal_set_updated(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.updated_ = value;
}

// string rendered_info = 28;
inline void AlarmLogEntry::clear_rendered_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rendered_info_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline const ::std::string& AlarmLogEntry::rendered_info() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.rendered_info)
  return _internal_rendered_info();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_rendered_info(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  _impl_.rendered_info_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.rendered_info)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_rendered_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::std::string* _s = _internal_mutable_rendered_info();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.rendered_info)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_rendered_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.rendered_info_.Get();
}
inline void AlarmLogEntry::_internal_set_rendered_info(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.rendered_info_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_rendered_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.rendered_info_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_rendered_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.rendered_info)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00001000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  auto* released = _impl_.rendered_info_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.rendered_info_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_rendered_info(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  }
  _impl_.rendered_info_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.rendered_info_.IsDefault()) {
    _impl_.rendered_info_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.rendered_info)
}

// string chart_context = 29;
inline void AlarmLogEntry::clear_chart_context() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_context_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline const ::std::string& AlarmLogEntry::chart_context() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.chart_context)
  return _internal_chart_context();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_chart_context(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  _impl_.chart_context_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.chart_context)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_chart_context()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::std::string* _s = _internal_mutable_chart_context();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.chart_context)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_chart_context() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chart_context_.Get();
}
inline void AlarmLogEntry::_internal_set_chart_context(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_context_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_chart_context() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.chart_context_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_chart_context() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.chart_context)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00002000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  auto* released = _impl_.chart_context_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.chart_context_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_chart_context(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  }
  _impl_.chart_context_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.chart_context_.IsDefault()) {
    _impl_.chart_context_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.chart_context)
}

// uint64 event_id = 30;
inline void AlarmLogEntry::clear_event_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.event_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
}
inline ::uint64_t AlarmLogEntry::event_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.event_id)
  return _internal_event_id();
}
inline void AlarmLogEntry::set_event_id(::uint64_t value) {
  _internal_set_event_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.event_id)
}
inline ::uint64_t AlarmLogEntry::_internal_event_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.event_id_;
}
inline void AlarmLogEntry::_internal_set_event_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.event_id_ = value;
}

// string transition_id = 31;
inline void AlarmLogEntry::clear_transition_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transition_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline const ::std::string& AlarmLogEntry::transition_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.transition_id)
  return _internal_transition_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_transition_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  _impl_.transition_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.transition_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_transition_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::std::string* _s = _internal_mutable_transition_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.transition_id)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_transition_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.transition_id_.Get();
}
inline void AlarmLogEntry::_internal_set_transition_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transition_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_transition_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.transition_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_transition_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.transition_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00004000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  auto* released = _impl_.transition_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.transition_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_transition_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  }
  _impl_.transition_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.transition_id_.IsDefault()) {
    _impl_.transition_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.transition_id)
}

// string chart_name = 32;
inline void AlarmLogEntry::clear_chart_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
}
inline const ::std::string& AlarmLogEntry::chart_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.chart_name)
  return _internal_chart_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_chart_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  _impl_.chart_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.chart_name)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_chart_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::std::string* _s = _internal_mutable_chart_name();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.chart_name)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_chart_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chart_name_.Get();
}
inline void AlarmLogEntry::_internal_set_chart_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_chart_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.chart_name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_chart_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.chart_name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x80000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  auto* released = _impl_.chart_name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.chart_name_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_chart_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  }
  _impl_.chart_name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.chart_name_.IsDefault()) {
    _impl_.chart_name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.chart_name)
}

// string summary = 33;
inline void AlarmLogEntry::clear_summary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.summary_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
}
inline const ::std::string& AlarmLogEntry::summary() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.summary)
  return _internal_summary();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmLogEntry::set_summary(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  _impl_.summary_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.summary)
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::mutable_summary()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::std::string* _s = _internal_mutable_summary();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmLogEntry.summary)
  return _s;
}
inline const ::std::string& AlarmLogEntry::_internal_summary() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.summary_.Get();
}
inline void AlarmLogEntry::_internal_set_summary(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.summary_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmLogEntry::_internal_mutable_summary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.summary_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmLogEntry::release_summary() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmLogEntry.summary)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  auto* released = _impl_.summary_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.summary_.Set("", GetArena());
  }
  return released;
}
inline void AlarmLogEntry::set_allocated_summary(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  }
  _impl_.summary_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.summary_.IsDefault()) {
    _impl_.summary_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmLogEntry.summary)
}

// uint64 alert_version = 34;
inline void AlarmLogEntry::clear_alert_version() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alert_version_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
}
inline ::uint64_t AlarmLogEntry::alert_version() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmLogEntry.alert_version)
  return _internal_alert_version();
}
inline void AlarmLogEntry::set_alert_version(::uint64_t value) {
  _internal_set_alert_version(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmLogEntry.alert_version)
}
inline ::uint64_t AlarmLogEntry::_internal_alert_version() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alert_version_;
}
inline void AlarmLogEntry::_internal_set_alert_version(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alert_version_ = value;
}

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

// SendAlarmSnapshot

// string node_id = 1;
inline void SendAlarmSnapshot::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& SendAlarmSnapshot::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmSnapshot.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmSnapshot::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmSnapshot.node_id)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmSnapshot.node_id)
  return _s;
}
inline const ::std::string& SendAlarmSnapshot::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void SendAlarmSnapshot::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmSnapshot::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmSnapshot.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmSnapshot::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmSnapshot.node_id)
}

// string claim_id = 2;
inline void SendAlarmSnapshot::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& SendAlarmSnapshot::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmSnapshot.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmSnapshot::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmSnapshot.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmSnapshot.claim_id)
  return _s;
}
inline const ::std::string& SendAlarmSnapshot::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void SendAlarmSnapshot::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmSnapshot::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmSnapshot.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmSnapshot::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmSnapshot.claim_id)
}

// uint64 snapshot_id = 3 [deprecated = true];
inline void SendAlarmSnapshot::clear_snapshot_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::uint64_t SendAlarmSnapshot::snapshot_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmSnapshot.snapshot_id)
  return _internal_snapshot_id();
}
inline void SendAlarmSnapshot::set_snapshot_id(::uint64_t value) {
  _internal_set_snapshot_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmSnapshot.snapshot_id)
}
inline ::uint64_t SendAlarmSnapshot::_internal_snapshot_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.snapshot_id_;
}
inline void SendAlarmSnapshot::_internal_set_snapshot_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_id_ = value;
}

// uint64 sequence_id = 4 [deprecated = true];
inline void SendAlarmSnapshot::clear_sequence_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint64_t SendAlarmSnapshot::sequence_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmSnapshot.sequence_id)
  return _internal_sequence_id();
}
inline void SendAlarmSnapshot::set_sequence_id(::uint64_t value) {
  _internal_set_sequence_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmSnapshot.sequence_id)
}
inline ::uint64_t SendAlarmSnapshot::_internal_sequence_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.sequence_id_;
}
inline void SendAlarmSnapshot::_internal_set_sequence_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.sequence_id_ = value;
}

// string snapshot_uuid = 5;
inline void SendAlarmSnapshot::clear_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_uuid_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& SendAlarmSnapshot::snapshot_uuid() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.SendAlarmSnapshot.snapshot_uuid)
  return _internal_snapshot_uuid();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SendAlarmSnapshot::set_snapshot_uuid(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.snapshot_uuid_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.SendAlarmSnapshot.snapshot_uuid)
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::mutable_snapshot_uuid()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_snapshot_uuid();
  // @@protoc_insertion_point(field_mutable:alarms.v1.SendAlarmSnapshot.snapshot_uuid)
  return _s;
}
inline const ::std::string& SendAlarmSnapshot::_internal_snapshot_uuid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.snapshot_uuid_.Get();
}
inline void SendAlarmSnapshot::_internal_set_snapshot_uuid(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_uuid_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SendAlarmSnapshot::_internal_mutable_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.snapshot_uuid_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SendAlarmSnapshot::release_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.SendAlarmSnapshot.snapshot_uuid)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.snapshot_uuid_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.snapshot_uuid_.Set("", GetArena());
  }
  return released;
}
inline void SendAlarmSnapshot::set_allocated_snapshot_uuid(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.snapshot_uuid_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.snapshot_uuid_.IsDefault()) {
    _impl_.snapshot_uuid_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.SendAlarmSnapshot.snapshot_uuid)
}

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

// AlarmSnapshot

// string node_id = 1;
inline void AlarmSnapshot::clear_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& AlarmSnapshot::node_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.node_id)
  return _internal_node_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmSnapshot::set_node_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.node_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.node_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::mutable_node_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_node_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmSnapshot.node_id)
  return _s;
}
inline const ::std::string& AlarmSnapshot::_internal_node_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_id_.Get();
}
inline void AlarmSnapshot::_internal_set_node_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::_internal_mutable_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.node_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmSnapshot::release_node_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmSnapshot.node_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.node_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.node_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmSnapshot::set_allocated_node_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.node_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.node_id_.IsDefault()) {
    _impl_.node_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmSnapshot.node_id)
}

// string claim_id = 2;
inline void AlarmSnapshot::clear_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& AlarmSnapshot::claim_id() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.claim_id)
  return _internal_claim_id();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmSnapshot::set_claim_id(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.claim_id_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.claim_id)
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::mutable_claim_id()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_claim_id();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmSnapshot.claim_id)
  return _s;
}
inline const ::std::string& AlarmSnapshot::_internal_claim_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.claim_id_.Get();
}
inline void AlarmSnapshot::_internal_set_claim_id(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.claim_id_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::_internal_mutable_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.claim_id_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmSnapshot::release_claim_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmSnapshot.claim_id)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.claim_id_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  return released;
}
inline void AlarmSnapshot::set_allocated_claim_id(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.claim_id_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.claim_id_.IsDefault()) {
    _impl_.claim_id_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmSnapshot.claim_id)
}

// uint64 snapshot_id = 3 [deprecated = true];
inline void AlarmSnapshot::clear_snapshot_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_id_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline ::uint64_t AlarmSnapshot::snapshot_id() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.snapshot_id)
  return _internal_snapshot_id();
}
inline void AlarmSnapshot::set_snapshot_id(::uint64_t value) {
  _internal_set_snapshot_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.snapshot_id)
}
inline ::uint64_t AlarmSnapshot::_internal_snapshot_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.snapshot_id_;
}
inline void AlarmSnapshot::_internal_set_snapshot_id(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_id_ = value;
}

// uint32 chunks = 4;
inline void AlarmSnapshot::clear_chunks() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunks_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline ::uint32_t AlarmSnapshot::chunks() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.chunks)
  return _internal_chunks();
}
inline void AlarmSnapshot::set_chunks(::uint32_t value) {
  _internal_set_chunks(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.chunks)
}
inline ::uint32_t AlarmSnapshot::_internal_chunks() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chunks_;
}
inline void AlarmSnapshot::_internal_set_chunks(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunks_ = value;
}

// uint32 chunk_size = 5;
inline void AlarmSnapshot::clear_chunk_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunk_size_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline ::uint32_t AlarmSnapshot::chunk_size() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.chunk_size)
  return _internal_chunk_size();
}
inline void AlarmSnapshot::set_chunk_size(::uint32_t value) {
  _internal_set_chunk_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.chunk_size)
}
inline ::uint32_t AlarmSnapshot::_internal_chunk_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chunk_size_;
}
inline void AlarmSnapshot::_internal_set_chunk_size(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunk_size_ = value;
}

// uint32 chunk = 6;
inline void AlarmSnapshot::clear_chunk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunk_ = 0u;
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline ::uint32_t AlarmSnapshot::chunk() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.chunk)
  return _internal_chunk();
}
inline void AlarmSnapshot::set_chunk(::uint32_t value) {
  _internal_set_chunk(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.chunk)
}
inline ::uint32_t AlarmSnapshot::_internal_chunk() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chunk_;
}
inline void AlarmSnapshot::_internal_set_chunk(::uint32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chunk_ = value;
}

// repeated .alarms.v1.AlarmLogEntry alarms = 7;
inline int AlarmSnapshot::_internal_alarms_size() const {
  return _internal_alarms().size();
}
inline int AlarmSnapshot::alarms_size() const {
  return _internal_alarms_size();
}
inline void AlarmSnapshot::clear_alarms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alarms_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::alarms::v1::AlarmLogEntry& AlarmSnapshot::alarms(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.alarms)
  return _internal_alarms().Get(index);
}
inline ::alarms::v1::AlarmLogEntry* PROTOBUF_NONNULL AlarmSnapshot::mutable_alarms(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmSnapshot.alarms)
  return _internal_mutable_alarms()->Mutable(index);
}
inline ::alarms::v1::AlarmLogEntry* PROTOBUF_NONNULL AlarmSnapshot::add_alarms()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::alarms::v1::AlarmLogEntry* _add =
      _internal_mutable_alarms()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:alarms.v1.AlarmSnapshot.alarms)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>& AlarmSnapshot::alarms() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:alarms.v1.AlarmSnapshot.alarms)
  return _internal_alarms();
}
inline ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>* PROTOBUF_NONNULL
AlarmSnapshot::mutable_alarms() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:alarms.v1.AlarmSnapshot.alarms)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_alarms();
}
inline const ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>&
AlarmSnapshot::_internal_alarms() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alarms_;
}
inline ::google::protobuf::RepeatedPtrField<::alarms::v1::AlarmLogEntry>* PROTOBUF_NONNULL
AlarmSnapshot::_internal_mutable_alarms() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.alarms_;
}

// string snapshot_uuid = 8;
inline void AlarmSnapshot::clear_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_uuid_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& AlarmSnapshot::snapshot_uuid() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmSnapshot.snapshot_uuid)
  return _internal_snapshot_uuid();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmSnapshot::set_snapshot_uuid(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.snapshot_uuid_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmSnapshot.snapshot_uuid)
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::mutable_snapshot_uuid()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_snapshot_uuid();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmSnapshot.snapshot_uuid)
  return _s;
}
inline const ::std::string& AlarmSnapshot::_internal_snapshot_uuid() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.snapshot_uuid_.Get();
}
inline void AlarmSnapshot::_internal_set_snapshot_uuid(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.snapshot_uuid_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmSnapshot::_internal_mutable_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.snapshot_uuid_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmSnapshot::release_snapshot_uuid() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmSnapshot.snapshot_uuid)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.snapshot_uuid_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.snapshot_uuid_.Set("", GetArena());
  }
  return released;
}
inline void AlarmSnapshot::set_allocated_snapshot_uuid(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  _impl_.snapshot_uuid_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.snapshot_uuid_.IsDefault()) {
    _impl_.snapshot_uuid_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmSnapshot.snapshot_uuid)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace alarms


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::alarms::v1::AlarmLogStatus> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::alarms::v1::AlarmLogStatus>() {
  return ::alarms::v1::AlarmLogStatus_descriptor();
}
template <>
struct is_proto_enum<::alarms::v1::AlarmStatus> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::alarms::v1::AlarmStatus>() {
  return ::alarms::v1::AlarmStatus_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // proto_2falarm_2fv1_2fstream_2eproto_2epb_2eh
