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

#ifndef alarm_2fv1_2fconfig_2eproto_2epb_2eh
#define alarm_2fv1_2fconfig_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/unknown_field_set.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_alarm_2fv1_2fconfig_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_alarm_2fv1_2fconfig_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
extern const ::google::protobuf::internal::DescriptorTable descriptor_table_alarm_2fv1_2fconfig_2eproto;
}  // extern "C"
namespace alarms {
namespace v1 {
class AlarmConfiguration;
struct AlarmConfigurationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern AlarmConfigurationGlobalsTypeInternal AlarmConfiguration_globals_;
extern const ::google::protobuf::internal::ClassDataFull AlarmConfiguration_class_data_;
#else
extern const AlarmConfigurationGlobalsTypeInternal AlarmConfiguration_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ProvideAlarmConfiguration;
struct ProvideAlarmConfigurationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ProvideAlarmConfigurationGlobalsTypeInternal ProvideAlarmConfiguration_globals_;
extern const ::google::protobuf::internal::ClassDataFull ProvideAlarmConfiguration_class_data_;
#else
extern const ProvideAlarmConfigurationGlobalsTypeInternal ProvideAlarmConfiguration_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SendAlarmConfiguration;
struct SendAlarmConfigurationGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SendAlarmConfigurationGlobalsTypeInternal SendAlarmConfiguration_globals_;
extern const ::google::protobuf::internal::ClassDataFull SendAlarmConfiguration_class_data_;
#else
extern const SendAlarmConfigurationGlobalsTypeInternal SendAlarmConfiguration_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace v1
}  // namespace alarms
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google

namespace alarms {
namespace v1 {

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


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

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

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

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

  inline SendAlarmConfiguration(const SendAlarmConfiguration& from) : SendAlarmConfiguration(nullptr, from) {}
  inline SendAlarmConfiguration(SendAlarmConfiguration&& from) noexcept : SendAlarmConfiguration(nullptr, ::std::move(from)) {}
  inline SendAlarmConfiguration& operator=(const SendAlarmConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline SendAlarmConfiguration& operator=(SendAlarmConfiguration&& 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 SendAlarmConfiguration& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SendAlarmConfiguration>(&SendAlarmConfiguration_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(SendAlarmConfiguration& a, SendAlarmConfiguration& b) { a.Swap(&b); }
  inline void Swap(SendAlarmConfiguration* 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(SendAlarmConfiguration* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] SendAlarmConfiguration* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SendAlarmConfiguration>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SendAlarmConfiguration& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SendAlarmConfiguration& from) { SendAlarmConfiguration::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(SendAlarmConfiguration* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.SendAlarmConfiguration"; }

  explicit SendAlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SendAlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SendAlarmConfiguration& from);
  SendAlarmConfiguration(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SendAlarmConfiguration&& from) noexcept
      : SendAlarmConfiguration(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 {
    kConfigHashFieldNumber = 1,
  };
  // string config_hash = 1;
  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:
  // @@protoc_insertion_point(class_scope:alarms.v1.SendAlarmConfiguration)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          0, 52,
                          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 SendAlarmConfiguration& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr config_hash_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_alarm_2fv1_2fconfig_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline AlarmConfiguration(const AlarmConfiguration& from) : AlarmConfiguration(nullptr, from) {}
  inline AlarmConfiguration(AlarmConfiguration&& from) noexcept : AlarmConfiguration(nullptr, ::std::move(from)) {}
  inline AlarmConfiguration& operator=(const AlarmConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline AlarmConfiguration& operator=(AlarmConfiguration&& 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 AlarmConfiguration& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<AlarmConfiguration>(&AlarmConfiguration_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(AlarmConfiguration& a, AlarmConfiguration& b) { a.Swap(&b); }
  inline void Swap(AlarmConfiguration* 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(AlarmConfiguration* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] AlarmConfiguration* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<AlarmConfiguration>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const AlarmConfiguration& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const AlarmConfiguration& from) { AlarmConfiguration::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(AlarmConfiguration* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.AlarmConfiguration"; }

  explicit AlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  AlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const AlarmConfiguration& from);
  AlarmConfiguration(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, AlarmConfiguration&& from) noexcept
      : AlarmConfiguration(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 {
    kAlarmFieldNumber = 1,
    kTemplateFieldNumber = 2,
    kOnChartFieldNumber = 3,
    kClassificationFieldNumber = 4,
    kTypeFieldNumber = 5,
    kComponentFieldNumber = 6,
    kOsFieldNumber = 7,
    kHostsFieldNumber = 8,
    kPluginFieldNumber = 9,
    kModuleFieldNumber = 10,
    kChartsFieldNumber = 11,
    kFamiliesFieldNumber = 12,
    kLookupFieldNumber = 13,
    kEveryFieldNumber = 14,
    kUnitsFieldNumber = 15,
    kGreenFieldNumber = 16,
    kRedFieldNumber = 17,
    kCalculationExprFieldNumber = 18,
    kWarningExprFieldNumber = 19,
    kCriticalExprFieldNumber = 20,
    kRecipientFieldNumber = 21,
    kExecFieldNumber = 22,
    kDelayFieldNumber = 23,
    kRepeatFieldNumber = 24,
    kInfoFieldNumber = 25,
    kOptionsFieldNumber = 26,
    kHostLabelsFieldNumber = 27,
    kPDbLookupDimensionsFieldNumber = 30,
    kPDbLookupMethodFieldNumber = 31,
    kPDbLookupAfterFieldNumber = 28,
    kPDbLookupBeforeFieldNumber = 29,
    kPDbLookupOptionsFieldNumber = 32,
    kChartLabelsFieldNumber = 34,
    kSummaryFieldNumber = 35,
    kPUpdateEveryFieldNumber = 33,
  };
  // string alarm = 1;
  void clear_alarm() ;
  [[nodiscard]] const ::std::string& alarm() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_alarm(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_alarm();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_alarm();
  void set_allocated_alarm(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_alarm() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_alarm(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_alarm();

  public:
  // string template = 2;
  void clear_template_() ;
  [[nodiscard]] const ::std::string& template_() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_template_(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_template_();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_template_();
  void set_allocated_template_(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_template_() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_template_(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_template_();

  public:
  // string on_chart = 3;
  void clear_on_chart() ;
  [[nodiscard]] const ::std::string& on_chart() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_on_chart(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_on_chart();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_on_chart();
  void set_allocated_on_chart(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_on_chart() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_on_chart(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_on_chart();

  public:
  // string classification = 4;
  void clear_classification() ;
  [[nodiscard]] const ::std::string& classification() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_classification(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_classification();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_classification();
  void set_allocated_classification(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_classification() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_classification(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_classification();

  public:
  // string type = 5;
  void clear_type() ;
  [[nodiscard]] const ::std::string& type() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_type(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_type();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_type();
  void set_allocated_type(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_type() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_type(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_type();

  public:
  // string component = 6;
  void clear_component() ;
  [[nodiscard]] const ::std::string& component() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_component(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_component();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_component();
  void set_allocated_component(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_component() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_component(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_component();

  public:
  // string os = 7;
  void clear_os() ;
  [[nodiscard]] const ::std::string& os() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_os(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_os();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_os();
  void set_allocated_os(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_os() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_os(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_os();

  public:
  // string hosts = 8;
  void clear_hosts() ;
  [[nodiscard]] const ::std::string& hosts() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_hosts(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_hosts();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_hosts();
  void set_allocated_hosts(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_hosts() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_hosts(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_hosts();

  public:
  // string plugin = 9;
  void clear_plugin() ;
  [[nodiscard]] const ::std::string& plugin() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_plugin(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_plugin();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_plugin();
  void set_allocated_plugin(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_plugin() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_plugin(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_plugin();

  public:
  // string module = 10;
  void clear_module() ;
  [[nodiscard]] const ::std::string& module() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_module(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_module();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_module();
  void set_allocated_module(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_module() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_module(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_module();

  public:
  // string charts = 11;
  void clear_charts() ;
  [[nodiscard]] const ::std::string& charts() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_charts(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_charts();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_charts();
  void set_allocated_charts(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_charts() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_charts(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_charts();

  public:
  // string families = 12 [deprecated = true];
  [[deprecated]]  void clear_families() ;
  [[nodiscard]] [[deprecated]] const ::std::string& families() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  [[deprecated]] void set_families(Arg_&& arg, Args_... args);
  [[deprecated]] ::std::string* PROTOBUF_NONNULL mutable_families();
  [[deprecated]] [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_families();
  [[deprecated]] void set_allocated_families(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_families() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_families(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_families();

  public:
  // string lookup = 13;
  void clear_lookup() ;
  [[nodiscard]] const ::std::string& lookup() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_lookup(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_lookup();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_lookup();
  void set_allocated_lookup(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_lookup() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_lookup(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_lookup();

  public:
  // string every = 14;
  void clear_every() ;
  [[nodiscard]] const ::std::string& every() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_every(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_every();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_every();
  void set_allocated_every(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_every() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_every(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_every();

  public:
  // string units = 15;
  void clear_units() ;
  [[nodiscard]] const ::std::string& units() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_units(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_units();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_units();
  void set_allocated_units(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_units() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_units(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_units();

  public:
  // string green = 16;
  void clear_green() ;
  [[nodiscard]] const ::std::string& green() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_green(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_green();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_green();
  void set_allocated_green(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_green() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_green(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_green();

  public:
  // string red = 17;
  void clear_red() ;
  [[nodiscard]] const ::std::string& red() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_red(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_red();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_red();
  void set_allocated_red(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_red() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_red(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_red();

  public:
  // string calculation_expr = 18;
  void clear_calculation_expr() ;
  [[nodiscard]] const ::std::string& calculation_expr() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_calculation_expr(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_calculation_expr();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_calculation_expr();
  void set_allocated_calculation_expr(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_calculation_expr() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_calculation_expr(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_calculation_expr();

  public:
  // string warning_expr = 19;
  void clear_warning_expr() ;
  [[nodiscard]] const ::std::string& warning_expr() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_warning_expr(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_warning_expr();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_warning_expr();
  void set_allocated_warning_expr(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_warning_expr() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_warning_expr(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_warning_expr();

  public:
  // string critical_expr = 20;
  void clear_critical_expr() ;
  [[nodiscard]] const ::std::string& critical_expr() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_critical_expr(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_critical_expr();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_critical_expr();
  void set_allocated_critical_expr(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_critical_expr() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_critical_expr(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_critical_expr();

  public:
  // string recipient = 21;
  void clear_recipient() ;
  [[nodiscard]] const ::std::string& recipient() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_recipient(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_recipient();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_recipient();
  void set_allocated_recipient(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_recipient() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_recipient(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_recipient();

  public:
  // string exec = 22;
  void clear_exec() ;
  [[nodiscard]] const ::std::string& exec() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_exec(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_exec();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_exec();
  void set_allocated_exec(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_exec() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_exec(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_exec();

  public:
  // string delay = 23;
  void clear_delay() ;
  [[nodiscard]] const ::std::string& delay() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_delay(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_delay();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_delay();
  void set_allocated_delay(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_delay() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_delay(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_delay();

  public:
  // string repeat = 24;
  void clear_repeat() ;
  [[nodiscard]] const ::std::string& repeat() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_repeat(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_repeat();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_repeat();
  void set_allocated_repeat(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_repeat() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_repeat(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_repeat();

  public:
  // string info = 25;
  void clear_info() ;
  [[nodiscard]] const ::std::string& info() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_info(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_info();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_info();
  void set_allocated_info(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_info() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_info(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_info();

  public:
  // string options = 26;
  void clear_options() ;
  [[nodiscard]] const ::std::string& options() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_options(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_options();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_options();
  void set_allocated_options(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_options() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_options(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_options();

  public:
  // string host_labels = 27;
  void clear_host_labels() ;
  [[nodiscard]] const ::std::string& host_labels() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_host_labels(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_host_labels();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_host_labels();
  void set_allocated_host_labels(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_host_labels() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_host_labels(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_host_labels();

  public:
  // string p_db_lookup_dimensions = 30;
  void clear_p_db_lookup_dimensions() ;
  [[nodiscard]] const ::std::string& p_db_lookup_dimensions() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_p_db_lookup_dimensions(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_p_db_lookup_dimensions();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_p_db_lookup_dimensions();
  void set_allocated_p_db_lookup_dimensions(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_p_db_lookup_dimensions() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_p_db_lookup_dimensions(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_p_db_lookup_dimensions();

  public:
  // string p_db_lookup_method = 31;
  void clear_p_db_lookup_method() ;
  [[nodiscard]] const ::std::string& p_db_lookup_method() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_p_db_lookup_method(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_p_db_lookup_method();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_p_db_lookup_method();
  void set_allocated_p_db_lookup_method(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_p_db_lookup_method() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_p_db_lookup_method(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_p_db_lookup_method();

  public:
  // int32 p_db_lookup_after = 28;
  void clear_p_db_lookup_after() ;
  [[nodiscard]] ::int32_t p_db_lookup_after() const;
  void set_p_db_lookup_after(::int32_t value);

  private:
  ::int32_t _internal_p_db_lookup_after() const;
  void _internal_set_p_db_lookup_after(::int32_t value);

  public:
  // int32 p_db_lookup_before = 29;
  void clear_p_db_lookup_before() ;
  [[nodiscard]] ::int32_t p_db_lookup_before() const;
  void set_p_db_lookup_before(::int32_t value);

  private:
  ::int32_t _internal_p_db_lookup_before() const;
  void _internal_set_p_db_lookup_before(::int32_t value);

  public:
  // string p_db_lookup_options = 32;
  void clear_p_db_lookup_options() ;
  [[nodiscard]] const ::std::string& p_db_lookup_options() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_p_db_lookup_options(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_p_db_lookup_options();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_p_db_lookup_options();
  void set_allocated_p_db_lookup_options(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_p_db_lookup_options() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_p_db_lookup_options(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_p_db_lookup_options();

  public:
  // string chart_labels = 34;
  void clear_chart_labels() ;
  [[nodiscard]] const ::std::string& chart_labels() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_chart_labels(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_chart_labels();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_chart_labels();
  void set_allocated_chart_labels(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_chart_labels() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_chart_labels(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_chart_labels();

  public:
  // string summary = 35;
  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:
  // int32 p_update_every = 33;
  void clear_p_update_every() ;
  [[nodiscard]] ::int32_t p_update_every() const;
  void set_p_update_every(::int32_t value);

  private:
  ::int32_t _internal_p_update_every() const;
  void _internal_set_p_update_every(::int32_t value);

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.AlarmConfiguration)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 35,
                          0, 339,
                          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 AlarmConfiguration& from_msg);
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr alarm_;
    ::google::protobuf::internal::ArenaStringPtr template__;
    ::google::protobuf::internal::ArenaStringPtr on_chart_;
    ::google::protobuf::internal::ArenaStringPtr classification_;
    ::google::protobuf::internal::ArenaStringPtr type_;
    ::google::protobuf::internal::ArenaStringPtr component_;
    ::google::protobuf::internal::ArenaStringPtr os_;
    ::google::protobuf::internal::ArenaStringPtr hosts_;
    ::google::protobuf::internal::ArenaStringPtr plugin_;
    ::google::protobuf::internal::ArenaStringPtr module_;
    ::google::protobuf::internal::ArenaStringPtr charts_;
    ::google::protobuf::internal::ArenaStringPtr families_;
    ::google::protobuf::internal::ArenaStringPtr lookup_;
    ::google::protobuf::internal::ArenaStringPtr every_;
    ::google::protobuf::internal::ArenaStringPtr units_;
    ::google::protobuf::internal::ArenaStringPtr green_;
    ::google::protobuf::internal::ArenaStringPtr red_;
    ::google::protobuf::internal::ArenaStringPtr calculation_expr_;
    ::google::protobuf::internal::ArenaStringPtr warning_expr_;
    ::google::protobuf::internal::ArenaStringPtr critical_expr_;
    ::google::protobuf::internal::ArenaStringPtr recipient_;
    ::google::protobuf::internal::ArenaStringPtr exec_;
    ::google::protobuf::internal::ArenaStringPtr delay_;
    ::google::protobuf::internal::ArenaStringPtr repeat_;
    ::google::protobuf::internal::ArenaStringPtr info_;
    ::google::protobuf::internal::ArenaStringPtr options_;
    ::google::protobuf::internal::ArenaStringPtr host_labels_;
    ::google::protobuf::internal::ArenaStringPtr p_db_lookup_dimensions_;
    ::google::protobuf::internal::ArenaStringPtr p_db_lookup_method_;
    ::int32_t p_db_lookup_after_;
    ::int32_t p_db_lookup_before_;
    ::google::protobuf::internal::ArenaStringPtr p_db_lookup_options_;
    ::google::protobuf::internal::ArenaStringPtr chart_labels_;
    ::google::protobuf::internal::ArenaStringPtr summary_;
    ::int32_t p_update_every_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_alarm_2fv1_2fconfig_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline ProvideAlarmConfiguration(const ProvideAlarmConfiguration& from) : ProvideAlarmConfiguration(nullptr, from) {}
  inline ProvideAlarmConfiguration(ProvideAlarmConfiguration&& from) noexcept : ProvideAlarmConfiguration(nullptr, ::std::move(from)) {}
  inline ProvideAlarmConfiguration& operator=(const ProvideAlarmConfiguration& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProvideAlarmConfiguration& operator=(ProvideAlarmConfiguration&& 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 ProvideAlarmConfiguration& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ProvideAlarmConfiguration>(&ProvideAlarmConfiguration_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(ProvideAlarmConfiguration& a, ProvideAlarmConfiguration& b) { a.Swap(&b); }
  inline void Swap(ProvideAlarmConfiguration* 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(ProvideAlarmConfiguration* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  [[nodiscard]] ProvideAlarmConfiguration* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ProvideAlarmConfiguration>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ProvideAlarmConfiguration& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ProvideAlarmConfiguration& from) { ProvideAlarmConfiguration::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(ProvideAlarmConfiguration* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "alarms.v1.ProvideAlarmConfiguration"; }

  explicit ProvideAlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ProvideAlarmConfiguration(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProvideAlarmConfiguration& from);
  ProvideAlarmConfiguration(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ProvideAlarmConfiguration&& from) noexcept
      : ProvideAlarmConfiguration(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 {
    kConfigHashFieldNumber = 1,
    kConfigFieldNumber = 2,
  };
  // string config_hash = 1;
  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:
  // .alarms.v1.AlarmConfiguration config = 2;
  [[nodiscard]] bool has_config()
      const;
  void clear_config() ;
  [[nodiscard]] const ::alarms::v1::AlarmConfiguration& config() const;
  [[nodiscard]] ::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE release_config();
  ::alarms::v1::AlarmConfiguration* PROTOBUF_NONNULL mutable_config();
  void set_allocated_config(::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_config(::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE value);
  ::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE unsafe_arena_release_config();

  private:
  const ::alarms::v1::AlarmConfiguration& _internal_config() const;
  ::alarms::v1::AlarmConfiguration* PROTOBUF_NONNULL _internal_mutable_config();

  public:
  // @@protoc_insertion_point(class_scope:alarms.v1.ProvideAlarmConfiguration)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          1, 55,
                          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 ProvideAlarmConfiguration& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr config_hash_;
    ::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE config_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_alarm_2fv1_2fconfig_2eproto;
};

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




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


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

// SendAlarmConfiguration

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

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

// ProvideAlarmConfiguration

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

// .alarms.v1.AlarmConfiguration config = 2;
inline bool ProvideAlarmConfiguration::has_config() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.config_ != nullptr);
  return value;
}
inline void ProvideAlarmConfiguration::clear_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ != nullptr) _impl_.config_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::alarms::v1::AlarmConfiguration& ProvideAlarmConfiguration::_internal_config() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::alarms::v1::AlarmConfiguration* p = _impl_.config_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::alarms::v1::AlarmConfiguration>(&::alarms::v1::AlarmConfiguration_globals_);
}
inline const ::alarms::v1::AlarmConfiguration& ProvideAlarmConfiguration::config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.ProvideAlarmConfiguration.config)
  return _internal_config();
}
inline void ProvideAlarmConfiguration::unsafe_arena_set_allocated_config(
    ::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }
  _impl_.config_ = reinterpret_cast<::alarms::v1::AlarmConfiguration*>(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.ProvideAlarmConfiguration.config)
}
inline ::alarms::v1::AlarmConfiguration* PROTOBUF_NULLABLE ProvideAlarmConfiguration::release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::alarms::v1::AlarmConfiguration* released = _impl_.config_;
  _impl_.config_ = 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::AlarmConfiguration* PROTOBUF_NULLABLE ProvideAlarmConfiguration::unsafe_arena_release_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.ProvideAlarmConfiguration.config)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::alarms::v1::AlarmConfiguration* temp = _impl_.config_;
  _impl_.config_ = nullptr;
  return temp;
}
inline ::alarms::v1::AlarmConfiguration* PROTOBUF_NONNULL ProvideAlarmConfiguration::_internal_mutable_config() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.config_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::alarms::v1::AlarmConfiguration>(GetArena());
    _impl_.config_ = reinterpret_cast<::alarms::v1::AlarmConfiguration*>(p);
  }
  return _impl_.config_;
}
inline ::alarms::v1::AlarmConfiguration* PROTOBUF_NONNULL ProvideAlarmConfiguration::mutable_config()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::alarms::v1::AlarmConfiguration* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:alarms.v1.ProvideAlarmConfiguration.config)
  return _msg;
}
inline void ProvideAlarmConfiguration::set_allocated_config(::alarms::v1::AlarmConfiguration* 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_.config_);
  }

  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], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.config_ = reinterpret_cast<::alarms::v1::AlarmConfiguration*>(value);
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.ProvideAlarmConfiguration.config)
}

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

// AlarmConfiguration

// string alarm = 1;
inline void AlarmConfiguration::clear_alarm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alarm_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& AlarmConfiguration::alarm() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.alarm)
  return _internal_alarm();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_alarm(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.alarm_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.alarm)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_alarm()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_alarm();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.alarm)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_alarm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alarm_.Get();
}
inline void AlarmConfiguration::_internal_set_alarm(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alarm_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_alarm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.alarm_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_alarm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.alarm)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.alarm_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.alarm_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_alarm(::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_.alarm_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.alarm_.IsDefault()) {
    _impl_.alarm_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.alarm)
}

// string template = 2;
inline void AlarmConfiguration::clear_template_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.template__.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& AlarmConfiguration::template_() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.template)
  return _internal_template_();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_template_(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.template__.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.template)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_template_()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_template_();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.template)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_template_() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.template__.Get();
}
inline void AlarmConfiguration::_internal_set_template_(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.template__.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_template_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.template__.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_template_() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.template)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.template__.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.template__.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_template_(::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_.template__.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.template__.IsDefault()) {
    _impl_.template__.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.template)
}

// string on_chart = 3;
inline void AlarmConfiguration::clear_on_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.on_chart_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& AlarmConfiguration::on_chart() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.on_chart)
  return _internal_on_chart();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_on_chart(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.on_chart_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.on_chart)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_on_chart()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_on_chart();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.on_chart)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_on_chart() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.on_chart_.Get();
}
inline void AlarmConfiguration::_internal_set_on_chart(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.on_chart_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_on_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.on_chart_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_on_chart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.on_chart)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.on_chart_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.on_chart_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_on_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_.on_chart_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.on_chart_.IsDefault()) {
    _impl_.on_chart_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.on_chart)
}

// string classification = 4;
inline void AlarmConfiguration::clear_classification() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.classification_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::std::string& AlarmConfiguration::classification() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.classification)
  return _internal_classification();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_classification(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  _impl_.classification_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.classification)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_classification()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::std::string* _s = _internal_mutable_classification();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.classification)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_classification() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.classification_.Get();
}
inline void AlarmConfiguration::_internal_set_classification(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.classification_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_classification() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.classification_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_classification() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.classification)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000008U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  auto* released = _impl_.classification_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.classification_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_classification(::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_.classification_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.classification_.IsDefault()) {
    _impl_.classification_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.classification)
}

// string type = 5;
inline void AlarmConfiguration::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& AlarmConfiguration::type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.type)
  return _internal_type();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_type(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.type)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_type()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_type();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.type)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.type_.Get();
}
inline void AlarmConfiguration::_internal_set_type(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.type_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.type)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.type_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.type_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_type(::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_.type_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.type_.IsDefault()) {
    _impl_.type_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.type)
}

// string component = 6;
inline void AlarmConfiguration::clear_component() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.component_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& AlarmConfiguration::component() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.component)
  return _internal_component();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_component(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.component_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.component)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_component()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_component();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.component)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_component() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.component_.Get();
}
inline void AlarmConfiguration::_internal_set_component(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.component_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_component() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.component_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_component() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.component)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.component_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.component_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_component(::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_.component_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.component_.IsDefault()) {
    _impl_.component_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.component)
}

// string os = 7;
inline void AlarmConfiguration::clear_os() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.os_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& AlarmConfiguration::os() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.os)
  return _internal_os();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_os(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.os_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.os)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_os()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_os();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.os)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_os() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.os_.Get();
}
inline void AlarmConfiguration::_internal_set_os(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.os_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_os() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.os_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_os() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.os)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  auto* released = _impl_.os_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.os_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_os(::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_.os_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.os_.IsDefault()) {
    _impl_.os_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.os)
}

// string hosts = 8;
inline void AlarmConfiguration::clear_hosts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hosts_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& AlarmConfiguration::hosts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.hosts)
  return _internal_hosts();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_hosts(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.hosts_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.hosts)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_hosts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_hosts();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.hosts)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_hosts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hosts_.Get();
}
inline void AlarmConfiguration::_internal_set_hosts(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hosts_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_hosts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.hosts_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_hosts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.hosts)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  auto* released = _impl_.hosts_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.hosts_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_hosts(::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_.hosts_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.hosts_.IsDefault()) {
    _impl_.hosts_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.hosts)
}

// string plugin = 9;
inline void AlarmConfiguration::clear_plugin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.plugin_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline const ::std::string& AlarmConfiguration::plugin() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.plugin)
  return _internal_plugin();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_plugin(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  _impl_.plugin_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.plugin)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_plugin()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::std::string* _s = _internal_mutable_plugin();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.plugin)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_plugin() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.plugin_.Get();
}
inline void AlarmConfiguration::_internal_set_plugin(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.plugin_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_plugin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.plugin_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_plugin() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.plugin)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000100U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  auto* released = _impl_.plugin_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.plugin_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_plugin(::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_.plugin_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.plugin_.IsDefault()) {
    _impl_.plugin_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.plugin)
}

// string module = 10;
inline void AlarmConfiguration::clear_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.module_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline const ::std::string& AlarmConfiguration::module() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.module)
  return _internal_module();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_module(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  _impl_.module_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.module)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_module()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::std::string* _s = _internal_mutable_module();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.module)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_module() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.module_.Get();
}
inline void AlarmConfiguration::_internal_set_module(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.module_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.module_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_module() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.module)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000200U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  auto* released = _impl_.module_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.module_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_module(::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_.module_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.module_.IsDefault()) {
    _impl_.module_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.module)
}

// string charts = 11;
inline void AlarmConfiguration::clear_charts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.charts_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline const ::std::string& AlarmConfiguration::charts() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.charts)
  return _internal_charts();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_charts(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  _impl_.charts_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.charts)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_charts()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  ::std::string* _s = _internal_mutable_charts();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.charts)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_charts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.charts_.Get();
}
inline void AlarmConfiguration::_internal_set_charts(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.charts_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_charts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.charts_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_charts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.charts)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000400U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
  auto* released = _impl_.charts_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.charts_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_charts(::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_.charts_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.charts_.IsDefault()) {
    _impl_.charts_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.charts)
}

// string families = 12 [deprecated = true];
inline void AlarmConfiguration::clear_families() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.families_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline const ::std::string& AlarmConfiguration::families() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.families)
  return _internal_families();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_families(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  _impl_.families_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.families)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_families()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  ::std::string* _s = _internal_mutable_families();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.families)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_families() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.families_.Get();
}
inline void AlarmConfiguration::_internal_set_families(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.families_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_families() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.families_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_families() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.families)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000800U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
  auto* released = _impl_.families_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.families_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_families(::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_.families_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.families_.IsDefault()) {
    _impl_.families_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.families)
}

// string lookup = 13;
inline void AlarmConfiguration::clear_lookup() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lookup_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline const ::std::string& AlarmConfiguration::lookup() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.lookup)
  return _internal_lookup();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_lookup(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  _impl_.lookup_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.lookup)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_lookup()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  ::std::string* _s = _internal_mutable_lookup();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.lookup)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_lookup() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lookup_.Get();
}
inline void AlarmConfiguration::_internal_set_lookup(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lookup_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_lookup() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.lookup_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_lookup() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.lookup)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00001000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
  auto* released = _impl_.lookup_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.lookup_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_lookup(::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_.lookup_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.lookup_.IsDefault()) {
    _impl_.lookup_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.lookup)
}

// string every = 14;
inline void AlarmConfiguration::clear_every() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.every_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline const ::std::string& AlarmConfiguration::every() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.every)
  return _internal_every();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_every(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  _impl_.every_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.every)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_every()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  ::std::string* _s = _internal_mutable_every();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.every)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_every() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.every_.Get();
}
inline void AlarmConfiguration::_internal_set_every(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.every_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_every() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.every_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_every() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.every)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00002000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
  auto* released = _impl_.every_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.every_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_every(::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_.every_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.every_.IsDefault()) {
    _impl_.every_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.every)
}

// string units = 15;
inline void AlarmConfiguration::clear_units() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.units_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline const ::std::string& AlarmConfiguration::units() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.units)
  return _internal_units();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_units(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  _impl_.units_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.units)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_units()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  ::std::string* _s = _internal_mutable_units();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.units)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_units() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.units_.Get();
}
inline void AlarmConfiguration::_internal_set_units(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.units_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_units() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.units_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_units() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.units)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00004000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
  auto* released = _impl_.units_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.units_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_units(::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_.units_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.units_.IsDefault()) {
    _impl_.units_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.units)
}

// string green = 16;
inline void AlarmConfiguration::clear_green() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.green_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline const ::std::string& AlarmConfiguration::green() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.green)
  return _internal_green();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_green(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  _impl_.green_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.green)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_green()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  ::std::string* _s = _internal_mutable_green();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.green)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_green() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.green_.Get();
}
inline void AlarmConfiguration::_internal_set_green(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.green_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_green() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.green_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_green() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.green)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00008000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  auto* released = _impl_.green_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.green_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_green(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
  }
  _impl_.green_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.green_.IsDefault()) {
    _impl_.green_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.green)
}

// string red = 17;
inline void AlarmConfiguration::clear_red() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.red_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline const ::std::string& AlarmConfiguration::red() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.red)
  return _internal_red();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_red(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  _impl_.red_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.red)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_red()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  ::std::string* _s = _internal_mutable_red();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.red)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_red() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.red_.Get();
}
inline void AlarmConfiguration::_internal_set_red(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.red_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_red() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.red_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_red() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.red)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00010000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  auto* released = _impl_.red_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.red_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_red(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
  }
  _impl_.red_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.red_.IsDefault()) {
    _impl_.red_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.red)
}

// string calculation_expr = 18;
inline void AlarmConfiguration::clear_calculation_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.calculation_expr_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline const ::std::string& AlarmConfiguration::calculation_expr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.calculation_expr)
  return _internal_calculation_expr();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_calculation_expr(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  _impl_.calculation_expr_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.calculation_expr)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_calculation_expr()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  ::std::string* _s = _internal_mutable_calculation_expr();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.calculation_expr)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_calculation_expr() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.calculation_expr_.Get();
}
inline void AlarmConfiguration::_internal_set_calculation_expr(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.calculation_expr_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_calculation_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.calculation_expr_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_calculation_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.calculation_expr)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00020000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  auto* released = _impl_.calculation_expr_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.calculation_expr_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_calculation_expr(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
  }
  _impl_.calculation_expr_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.calculation_expr_.IsDefault()) {
    _impl_.calculation_expr_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.calculation_expr)
}

// string warning_expr = 19;
inline void AlarmConfiguration::clear_warning_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.warning_expr_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline const ::std::string& AlarmConfiguration::warning_expr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.warning_expr)
  return _internal_warning_expr();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_warning_expr(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  _impl_.warning_expr_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.warning_expr)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_warning_expr()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  ::std::string* _s = _internal_mutable_warning_expr();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.warning_expr)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_warning_expr() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.warning_expr_.Get();
}
inline void AlarmConfiguration::_internal_set_warning_expr(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.warning_expr_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_warning_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.warning_expr_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_warning_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.warning_expr)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00040000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  auto* released = _impl_.warning_expr_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.warning_expr_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_warning_expr(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
  }
  _impl_.warning_expr_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.warning_expr_.IsDefault()) {
    _impl_.warning_expr_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.warning_expr)
}

// string critical_expr = 20;
inline void AlarmConfiguration::clear_critical_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.critical_expr_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline const ::std::string& AlarmConfiguration::critical_expr() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.critical_expr)
  return _internal_critical_expr();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_critical_expr(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  _impl_.critical_expr_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.critical_expr)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_critical_expr()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  ::std::string* _s = _internal_mutable_critical_expr();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.critical_expr)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_critical_expr() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.critical_expr_.Get();
}
inline void AlarmConfiguration::_internal_set_critical_expr(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.critical_expr_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_critical_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.critical_expr_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_critical_expr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.critical_expr)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00080000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  auto* released = _impl_.critical_expr_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.critical_expr_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_critical_expr(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
  }
  _impl_.critical_expr_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.critical_expr_.IsDefault()) {
    _impl_.critical_expr_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.critical_expr)
}

// string recipient = 21;
inline void AlarmConfiguration::clear_recipient() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recipient_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline const ::std::string& AlarmConfiguration::recipient() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.recipient)
  return _internal_recipient();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_recipient(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  _impl_.recipient_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.recipient)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_recipient()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  ::std::string* _s = _internal_mutable_recipient();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.recipient)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_recipient() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.recipient_.Get();
}
inline void AlarmConfiguration::_internal_set_recipient(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.recipient_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_recipient() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.recipient_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_recipient() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.recipient)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00100000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  auto* released = _impl_.recipient_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.recipient_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_recipient(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
  }
  _impl_.recipient_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.recipient_.IsDefault()) {
    _impl_.recipient_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.recipient)
}

// string exec = 22;
inline void AlarmConfiguration::clear_exec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline const ::std::string& AlarmConfiguration::exec() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.exec)
  return _internal_exec();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_exec(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  _impl_.exec_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.exec)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_exec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  ::std::string* _s = _internal_mutable_exec();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.exec)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_exec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exec_.Get();
}
inline void AlarmConfiguration::_internal_set_exec(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exec_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_exec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.exec_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_exec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.exec)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00200000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  auto* released = _impl_.exec_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.exec_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_exec(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
  }
  _impl_.exec_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.exec_.IsDefault()) {
    _impl_.exec_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.exec)
}

// string delay = 23;
inline void AlarmConfiguration::clear_delay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline const ::std::string& AlarmConfiguration::delay() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.delay)
  return _internal_delay();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_delay(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  _impl_.delay_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.delay)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_delay()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  ::std::string* _s = _internal_mutable_delay();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.delay)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_delay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.delay_.Get();
}
inline void AlarmConfiguration::_internal_set_delay(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.delay_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_delay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.delay_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_delay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.delay)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00400000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
  auto* released = _impl_.delay_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.delay_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_delay(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
  }
  _impl_.delay_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.delay_.IsDefault()) {
    _impl_.delay_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.delay)
}

// string repeat = 24;
inline void AlarmConfiguration::clear_repeat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.repeat_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline const ::std::string& AlarmConfiguration::repeat() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.repeat)
  return _internal_repeat();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_repeat(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  _impl_.repeat_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.repeat)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_repeat()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  ::std::string* _s = _internal_mutable_repeat();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.repeat)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_repeat() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.repeat_.Get();
}
inline void AlarmConfiguration::_internal_set_repeat(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.repeat_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_repeat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.repeat_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_repeat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.repeat)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00800000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
  auto* released = _impl_.repeat_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.repeat_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_repeat(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
  }
  _impl_.repeat_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.repeat_.IsDefault()) {
    _impl_.repeat_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.repeat)
}

// string info = 25;
inline void AlarmConfiguration::clear_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.info_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline const ::std::string& AlarmConfiguration::info() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.info)
  return _internal_info();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_info(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  _impl_.info_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.info)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_info()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  ::std::string* _s = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.info)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_info() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.info_.Get();
}
inline void AlarmConfiguration::_internal_set_info(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.info_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.info_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_info() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.info)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x01000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
  auto* released = _impl_.info_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.info_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_info(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
  }
  _impl_.info_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.info_.IsDefault()) {
    _impl_.info_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.info)
}

// string options = 26;
inline void AlarmConfiguration::clear_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
}
inline const ::std::string& AlarmConfiguration::options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.options)
  return _internal_options();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_options(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  _impl_.options_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.options)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  ::std::string* _s = _internal_mutable_options();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.options)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.options_.Get();
}
inline void AlarmConfiguration::_internal_set_options(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.options_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.options_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.options)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x02000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
  auto* released = _impl_.options_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.options_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_options(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
  }
  _impl_.options_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.options_.IsDefault()) {
    _impl_.options_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.options)
}

// string host_labels = 27;
inline void AlarmConfiguration::clear_host_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.host_labels_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
}
inline const ::std::string& AlarmConfiguration::host_labels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.host_labels)
  return _internal_host_labels();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_host_labels(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  _impl_.host_labels_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.host_labels)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_host_labels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  ::std::string* _s = _internal_mutable_host_labels();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.host_labels)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_host_labels() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.host_labels_.Get();
}
inline void AlarmConfiguration::_internal_set_host_labels(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.host_labels_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_host_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.host_labels_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_host_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.host_labels)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x04000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
  auto* released = _impl_.host_labels_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.host_labels_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_host_labels(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
  }
  _impl_.host_labels_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.host_labels_.IsDefault()) {
    _impl_.host_labels_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.host_labels)
}

// int32 p_db_lookup_after = 28;
inline void AlarmConfiguration::clear_p_db_lookup_after() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_after_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
}
inline ::int32_t AlarmConfiguration::p_db_lookup_after() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_db_lookup_after)
  return _internal_p_db_lookup_after();
}
inline void AlarmConfiguration::set_p_db_lookup_after(::int32_t value) {
  _internal_set_p_db_lookup_after(value);
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_db_lookup_after)
}
inline ::int32_t AlarmConfiguration::_internal_p_db_lookup_after() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_db_lookup_after_;
}
inline void AlarmConfiguration::_internal_set_p_db_lookup_after(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_after_ = value;
}

// int32 p_db_lookup_before = 29;
inline void AlarmConfiguration::clear_p_db_lookup_before() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_before_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
}
inline ::int32_t AlarmConfiguration::p_db_lookup_before() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_db_lookup_before)
  return _internal_p_db_lookup_before();
}
inline void AlarmConfiguration::set_p_db_lookup_before(::int32_t value) {
  _internal_set_p_db_lookup_before(value);
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_db_lookup_before)
}
inline ::int32_t AlarmConfiguration::_internal_p_db_lookup_before() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_db_lookup_before_;
}
inline void AlarmConfiguration::_internal_set_p_db_lookup_before(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_before_ = value;
}

// string p_db_lookup_dimensions = 30;
inline void AlarmConfiguration::clear_p_db_lookup_dimensions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_dimensions_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
}
inline const ::std::string& AlarmConfiguration::p_db_lookup_dimensions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_db_lookup_dimensions)
  return _internal_p_db_lookup_dimensions();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_p_db_lookup_dimensions(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  _impl_.p_db_lookup_dimensions_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_db_lookup_dimensions)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_p_db_lookup_dimensions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  ::std::string* _s = _internal_mutable_p_db_lookup_dimensions();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.p_db_lookup_dimensions)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_p_db_lookup_dimensions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_db_lookup_dimensions_.Get();
}
inline void AlarmConfiguration::_internal_set_p_db_lookup_dimensions(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_dimensions_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_p_db_lookup_dimensions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.p_db_lookup_dimensions_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_p_db_lookup_dimensions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.p_db_lookup_dimensions)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x08000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
  auto* released = _impl_.p_db_lookup_dimensions_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.p_db_lookup_dimensions_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_p_db_lookup_dimensions(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
  }
  _impl_.p_db_lookup_dimensions_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.p_db_lookup_dimensions_.IsDefault()) {
    _impl_.p_db_lookup_dimensions_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.p_db_lookup_dimensions)
}

// string p_db_lookup_method = 31;
inline void AlarmConfiguration::clear_p_db_lookup_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_method_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
}
inline const ::std::string& AlarmConfiguration::p_db_lookup_method() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_db_lookup_method)
  return _internal_p_db_lookup_method();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_p_db_lookup_method(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  _impl_.p_db_lookup_method_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_db_lookup_method)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_p_db_lookup_method()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  ::std::string* _s = _internal_mutable_p_db_lookup_method();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.p_db_lookup_method)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_p_db_lookup_method() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_db_lookup_method_.Get();
}
inline void AlarmConfiguration::_internal_set_p_db_lookup_method(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_method_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_p_db_lookup_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.p_db_lookup_method_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_p_db_lookup_method() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.p_db_lookup_method)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x10000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  auto* released = _impl_.p_db_lookup_method_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.p_db_lookup_method_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_p_db_lookup_method(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  }
  _impl_.p_db_lookup_method_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.p_db_lookup_method_.IsDefault()) {
    _impl_.p_db_lookup_method_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.p_db_lookup_method)
}

// string p_db_lookup_options = 32;
inline void AlarmConfiguration::clear_p_db_lookup_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_options_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
}
inline const ::std::string& AlarmConfiguration::p_db_lookup_options() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_db_lookup_options)
  return _internal_p_db_lookup_options();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_p_db_lookup_options(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  _impl_.p_db_lookup_options_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_db_lookup_options)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_p_db_lookup_options()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::std::string* _s = _internal_mutable_p_db_lookup_options();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.p_db_lookup_options)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_p_db_lookup_options() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_db_lookup_options_.Get();
}
inline void AlarmConfiguration::_internal_set_p_db_lookup_options(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_db_lookup_options_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_p_db_lookup_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.p_db_lookup_options_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_p_db_lookup_options() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.p_db_lookup_options)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x80000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  auto* released = _impl_.p_db_lookup_options_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.p_db_lookup_options_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_p_db_lookup_options(::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_.p_db_lookup_options_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.p_db_lookup_options_.IsDefault()) {
    _impl_.p_db_lookup_options_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.p_db_lookup_options)
}

// int32 p_update_every = 33;
inline void AlarmConfiguration::clear_p_update_every() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_update_every_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
}
inline ::int32_t AlarmConfiguration::p_update_every() const {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.p_update_every)
  return _internal_p_update_every();
}
inline void AlarmConfiguration::set_p_update_every(::int32_t value) {
  _internal_set_p_update_every(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.p_update_every)
}
inline ::int32_t AlarmConfiguration::_internal_p_update_every() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.p_update_every_;
}
inline void AlarmConfiguration::_internal_set_p_update_every(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.p_update_every_ = value;
}

// string chart_labels = 34;
inline void AlarmConfiguration::clear_chart_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_labels_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
}
inline const ::std::string& AlarmConfiguration::chart_labels() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:alarms.v1.AlarmConfiguration.chart_labels)
  return _internal_chart_labels();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void AlarmConfiguration::set_chart_labels(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  _impl_.chart_labels_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:alarms.v1.AlarmConfiguration.chart_labels)
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::mutable_chart_labels()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::std::string* _s = _internal_mutable_chart_labels();
  // @@protoc_insertion_point(field_mutable:alarms.v1.AlarmConfiguration.chart_labels)
  return _s;
}
inline const ::std::string& AlarmConfiguration::_internal_chart_labels() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chart_labels_.Get();
}
inline void AlarmConfiguration::_internal_set_chart_labels(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chart_labels_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL AlarmConfiguration::_internal_mutable_chart_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.chart_labels_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE AlarmConfiguration::release_chart_labels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:alarms.v1.AlarmConfiguration.chart_labels)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  auto* released = _impl_.chart_labels_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.chart_labels_.Set("", GetArena());
  }
  return released;
}
inline void AlarmConfiguration::set_allocated_chart_labels(::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_.chart_labels_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.chart_labels_.IsDefault()) {
    _impl_.chart_labels_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:alarms.v1.AlarmConfiguration.chart_labels)
}

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

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

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


// @@protoc_insertion_point(global_scope)

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

#endif  // alarm_2fv1_2fconfig_2eproto_2epb_2eh
