// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: keyapis/telemetry_control/v1/keyapis_telemetry_control_events_v1.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto_2epb_2eh

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

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION < 4023000
#error "This file was generated by a newer version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please update"
#error "your headers."
#endif  // PROTOBUF_VERSION

#if 4023001 < PROTOBUF_MIN_PROTOC_VERSION
#error "This file was generated by an older version of protoc which is"
#error "incompatible with your Protocol Buffer headers. Please"
#error "regenerate this file with a newer version of protoc."
#endif  // PROTOBUF_MIN_PROTOC_VERSION
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
#include "google/api/field_behavior.pb.h"
// @@protoc_insertion_point(includes)

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

#define PROTOBUF_INTERNAL_EXPORT_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto

PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto {
  static const ::uint32_t offsets[];
};
namespace keyapis {
namespace telemetry_control {
namespace v1 {
class CollectorParams;
struct CollectorParamsDefaultTypeInternal;
extern CollectorParamsDefaultTypeInternal _CollectorParams_default_instance_;
class EICAllFiasStartTask;
struct EICAllFiasStartTaskDefaultTypeInternal;
extern EICAllFiasStartTaskDefaultTypeInternal _EICAllFiasStartTask_default_instance_;
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template <>
::keyapis::telemetry_control::v1::CollectorParams* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::CollectorParams>(Arena*);
template <>
::keyapis::telemetry_control::v1::EICAllFiasStartTask* Arena::CreateMaybeMessage<::keyapis::telemetry_control::v1::EICAllFiasStartTask>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

namespace keyapis {
namespace telemetry_control {
namespace v1 {
enum CollectorParams_SignType : int {
  CollectorParams_SignType_SIGN_TYPE_UNKNOWN = 0,
  CollectorParams_SignType_ABSOLUTE_DS = 1,
  CollectorParams_SignType_ABSOLUTE_RC = 2,
  CollectorParams_SignType_INTERVAL_DS = 3,
  CollectorParams_SignType_INTERVAL_RC = 4,
  CollectorParams_SignType_CURRENT_DS = 5,
  CollectorParams_SignType_CURRENT_RS = 6,
  CollectorParams_SignType_VOLUME = 7,
  CollectorParams_SignType_PARAMETER = 8,
  CollectorParams_SignType_FLAG = 9,
  CollectorParams_SignType_CollectorParams_SignType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  CollectorParams_SignType_CollectorParams_SignType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CollectorParams_SignType_IsValid(int value);
constexpr CollectorParams_SignType CollectorParams_SignType_SignType_MIN = static_cast<CollectorParams_SignType>(0);
constexpr CollectorParams_SignType CollectorParams_SignType_SignType_MAX = static_cast<CollectorParams_SignType>(9);
constexpr int CollectorParams_SignType_SignType_ARRAYSIZE = 9 + 1;
const std::string& CollectorParams_SignType_Name(CollectorParams_SignType value);
template <typename T>
const std::string& CollectorParams_SignType_Name(T value) {
  static_assert(std::is_same<T, CollectorParams_SignType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to SignType_Name().");
  return CollectorParams_SignType_Name(static_cast<CollectorParams_SignType>(value));
}
const std::string& CollectorParams_SignType_Name(CollectorParams_SignType value);
bool CollectorParams_SignType_Parse(absl::string_view name, CollectorParams_SignType* value);
enum CollectorParams_ArchiveType : int {
  CollectorParams_ArchiveType_ARCHIVE_TYPE_UNKNOWN = 0,
  CollectorParams_ArchiveType_CURRENT = 1,
  CollectorParams_ArchiveType_HALFHOUR = 2,
  CollectorParams_ArchiveType_HOUR = 3,
  CollectorParams_ArchiveType_DAY = 4,
  CollectorParams_ArchiveType_MONTH = 5,
  CollectorParams_ArchiveType_YEAR = 6,
  CollectorParams_ArchiveType_CollectorParams_ArchiveType_INT_MIN_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::min(),
  CollectorParams_ArchiveType_CollectorParams_ArchiveType_INT_MAX_SENTINEL_DO_NOT_USE_ =
      std::numeric_limits<::int32_t>::max(),
};

bool CollectorParams_ArchiveType_IsValid(int value);
constexpr CollectorParams_ArchiveType CollectorParams_ArchiveType_ArchiveType_MIN = static_cast<CollectorParams_ArchiveType>(0);
constexpr CollectorParams_ArchiveType CollectorParams_ArchiveType_ArchiveType_MAX = static_cast<CollectorParams_ArchiveType>(6);
constexpr int CollectorParams_ArchiveType_ArchiveType_ARRAYSIZE = 6 + 1;
const std::string& CollectorParams_ArchiveType_Name(CollectorParams_ArchiveType value);
template <typename T>
const std::string& CollectorParams_ArchiveType_Name(T value) {
  static_assert(std::is_same<T, CollectorParams_ArchiveType>::value ||
                    std::is_integral<T>::value,
                "Incorrect type passed to ArchiveType_Name().");
  return CollectorParams_ArchiveType_Name(static_cast<CollectorParams_ArchiveType>(value));
}
const std::string& CollectorParams_ArchiveType_Name(CollectorParams_ArchiveType value);
bool CollectorParams_ArchiveType_Parse(absl::string_view name, CollectorParams_ArchiveType* value);

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


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

class CollectorParams final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.CollectorParams) */ {
 public:
  inline CollectorParams() : CollectorParams(nullptr) {}
  ~CollectorParams() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR CollectorParams(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CollectorParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.telemetry_control.v1.CollectorParams";
  }
  protected:
  explicit CollectorParams(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

  using SignType = CollectorParams_SignType;
  static constexpr SignType SIGN_TYPE_UNKNOWN = CollectorParams_SignType_SIGN_TYPE_UNKNOWN;
  static constexpr SignType ABSOLUTE_DS = CollectorParams_SignType_ABSOLUTE_DS;
  static constexpr SignType ABSOLUTE_RC = CollectorParams_SignType_ABSOLUTE_RC;
  static constexpr SignType INTERVAL_DS = CollectorParams_SignType_INTERVAL_DS;
  static constexpr SignType INTERVAL_RC = CollectorParams_SignType_INTERVAL_RC;
  static constexpr SignType CURRENT_DS = CollectorParams_SignType_CURRENT_DS;
  static constexpr SignType CURRENT_RS = CollectorParams_SignType_CURRENT_RS;
  static constexpr SignType VOLUME = CollectorParams_SignType_VOLUME;
  static constexpr SignType PARAMETER = CollectorParams_SignType_PARAMETER;
  static constexpr SignType FLAG = CollectorParams_SignType_FLAG;
  static inline bool SignType_IsValid(int value) {
    return CollectorParams_SignType_IsValid(value);
  }
  static constexpr SignType SignType_MIN = CollectorParams_SignType_SignType_MIN;
  static constexpr SignType SignType_MAX = CollectorParams_SignType_SignType_MAX;
  static constexpr int SignType_ARRAYSIZE = CollectorParams_SignType_SignType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& SignType_Name(T value) {
    return CollectorParams_SignType_Name(value);
  }
  static inline bool SignType_Parse(absl::string_view name, SignType* value) {
    return CollectorParams_SignType_Parse(name, value);
  }

  using ArchiveType = CollectorParams_ArchiveType;
  static constexpr ArchiveType ARCHIVE_TYPE_UNKNOWN = CollectorParams_ArchiveType_ARCHIVE_TYPE_UNKNOWN;
  static constexpr ArchiveType CURRENT = CollectorParams_ArchiveType_CURRENT;
  static constexpr ArchiveType HALFHOUR = CollectorParams_ArchiveType_HALFHOUR;
  static constexpr ArchiveType HOUR = CollectorParams_ArchiveType_HOUR;
  static constexpr ArchiveType DAY = CollectorParams_ArchiveType_DAY;
  static constexpr ArchiveType MONTH = CollectorParams_ArchiveType_MONTH;
  static constexpr ArchiveType YEAR = CollectorParams_ArchiveType_YEAR;
  static inline bool ArchiveType_IsValid(int value) {
    return CollectorParams_ArchiveType_IsValid(value);
  }
  static constexpr ArchiveType ArchiveType_MIN = CollectorParams_ArchiveType_ArchiveType_MIN;
  static constexpr ArchiveType ArchiveType_MAX = CollectorParams_ArchiveType_ArchiveType_MAX;
  static constexpr int ArchiveType_ARRAYSIZE = CollectorParams_ArchiveType_ArchiveType_ARRAYSIZE;
  template <typename T>
  static inline const std::string& ArchiveType_Name(T value) {
    return CollectorParams_ArchiveType_Name(value);
  }
  static inline bool ArchiveType_Parse(absl::string_view name, ArchiveType* value) {
    return CollectorParams_ArchiveType_Parse(name, value);
  }

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

  enum : int {
    kDateFieldNumber = 1,
    kArchiveTypeFieldNumber = 2,
    kSignTypeFieldNumber = 3,
  };
  // string date = 1;
  void clear_date() ;
  const std::string& date() const;




  template <typename Arg_ = const std::string&, typename... Args_>
  void set_date(Arg_&& arg, Args_... args);
  std::string* mutable_date();
  PROTOBUF_NODISCARD std::string* release_date();
  void set_allocated_date(std::string* ptr);

  private:
  const std::string& _internal_date() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_date(
      const std::string& value);
  std::string* _internal_mutable_date();

  public:
  // .keyapis.telemetry_control.v1.CollectorParams.ArchiveType archive_type = 2;
  void clear_archive_type() ;
  ::keyapis::telemetry_control::v1::CollectorParams_ArchiveType archive_type() const;
  void set_archive_type(::keyapis::telemetry_control::v1::CollectorParams_ArchiveType value);

  private:
  ::keyapis::telemetry_control::v1::CollectorParams_ArchiveType _internal_archive_type() const;
  void _internal_set_archive_type(::keyapis::telemetry_control::v1::CollectorParams_ArchiveType value);

  public:
  // .keyapis.telemetry_control.v1.CollectorParams.SignType sign_type = 3;
  void clear_sign_type() ;
  ::keyapis::telemetry_control::v1::CollectorParams_SignType sign_type() const;
  void set_sign_type(::keyapis::telemetry_control::v1::CollectorParams_SignType value);

  private:
  ::keyapis::telemetry_control::v1::CollectorParams_SignType _internal_sign_type() const;
  void _internal_set_sign_type(::keyapis::telemetry_control::v1::CollectorParams_SignType value);

  public:
  // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.CollectorParams)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr date_;
    int archive_type_;
    int sign_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto;
};// -------------------------------------------------------------------

class EICAllFiasStartTask final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:keyapis.telemetry_control.v1.EICAllFiasStartTask) */ {
 public:
  inline EICAllFiasStartTask() : EICAllFiasStartTask(nullptr) {}
  ~EICAllFiasStartTask() override;
  template<typename = void>
  explicit PROTOBUF_CONSTEXPR EICAllFiasStartTask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EICAllFiasStartTask* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() {
    return "keyapis.telemetry_control.v1.EICAllFiasStartTask";
  }
  protected:
  explicit EICAllFiasStartTask(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kCollectorParamsFieldNumber = 1,
  };
  // .keyapis.telemetry_control.v1.CollectorParams collector_params = 1 [(.google.api.field_behavior) = REQUIRED];
  bool has_collector_params() const;
  void clear_collector_params() ;
  const ::keyapis::telemetry_control::v1::CollectorParams& collector_params() const;
  PROTOBUF_NODISCARD ::keyapis::telemetry_control::v1::CollectorParams* release_collector_params();
  ::keyapis::telemetry_control::v1::CollectorParams* mutable_collector_params();
  void set_allocated_collector_params(::keyapis::telemetry_control::v1::CollectorParams* collector_params);
  private:
  const ::keyapis::telemetry_control::v1::CollectorParams& _internal_collector_params() const;
  ::keyapis::telemetry_control::v1::CollectorParams* _internal_mutable_collector_params();
  public:
  void unsafe_arena_set_allocated_collector_params(
      ::keyapis::telemetry_control::v1::CollectorParams* collector_params);
  ::keyapis::telemetry_control::v1::CollectorParams* unsafe_arena_release_collector_params();
  // @@protoc_insertion_point(class_scope:keyapis.telemetry_control.v1.EICAllFiasStartTask)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::keyapis::telemetry_control::v1::CollectorParams* collector_params_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto;
};

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




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


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

// CollectorParams

// string date = 1;
inline void CollectorParams::clear_date() {
  _impl_.date_.ClearToEmpty();
}
inline const std::string& CollectorParams::date() const {
  // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.CollectorParams.date)
  return _internal_date();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void CollectorParams::set_date(Arg_&& arg,
                                                     Args_... args) {
  ;
  _impl_.date_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.CollectorParams.date)
}
inline std::string* CollectorParams::mutable_date() {
  std::string* _s = _internal_mutable_date();
  // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.CollectorParams.date)
  return _s;
}
inline const std::string& CollectorParams::_internal_date() const {
  return _impl_.date_.Get();
}
inline void CollectorParams::_internal_set_date(const std::string& value) {
  ;


  _impl_.date_.Set(value, GetArenaForAllocation());
}
inline std::string* CollectorParams::_internal_mutable_date() {
  ;
  return _impl_.date_.Mutable( GetArenaForAllocation());
}
inline std::string* CollectorParams::release_date() {
  // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.CollectorParams.date)
  return _impl_.date_.Release();
}
inline void CollectorParams::set_allocated_date(std::string* value) {
  _impl_.date_.SetAllocated(value, GetArenaForAllocation());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.date_.IsDefault()) {
          _impl_.date_.Set("", GetArenaForAllocation());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.CollectorParams.date)
}

// .keyapis.telemetry_control.v1.CollectorParams.ArchiveType archive_type = 2;
inline void CollectorParams::clear_archive_type() {
  _impl_.archive_type_ = 0;
}
inline ::keyapis::telemetry_control::v1::CollectorParams_ArchiveType CollectorParams::archive_type() const {
  // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.CollectorParams.archive_type)
  return _internal_archive_type();
}
inline void CollectorParams::set_archive_type(::keyapis::telemetry_control::v1::CollectorParams_ArchiveType value) {
   _internal_set_archive_type(value);
  // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.CollectorParams.archive_type)
}
inline ::keyapis::telemetry_control::v1::CollectorParams_ArchiveType CollectorParams::_internal_archive_type() const {
  return static_cast<::keyapis::telemetry_control::v1::CollectorParams_ArchiveType>(_impl_.archive_type_);
}
inline void CollectorParams::_internal_set_archive_type(::keyapis::telemetry_control::v1::CollectorParams_ArchiveType value) {
  ;
  _impl_.archive_type_ = value;
}

// .keyapis.telemetry_control.v1.CollectorParams.SignType sign_type = 3;
inline void CollectorParams::clear_sign_type() {
  _impl_.sign_type_ = 0;
}
inline ::keyapis::telemetry_control::v1::CollectorParams_SignType CollectorParams::sign_type() const {
  // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.CollectorParams.sign_type)
  return _internal_sign_type();
}
inline void CollectorParams::set_sign_type(::keyapis::telemetry_control::v1::CollectorParams_SignType value) {
   _internal_set_sign_type(value);
  // @@protoc_insertion_point(field_set:keyapis.telemetry_control.v1.CollectorParams.sign_type)
}
inline ::keyapis::telemetry_control::v1::CollectorParams_SignType CollectorParams::_internal_sign_type() const {
  return static_cast<::keyapis::telemetry_control::v1::CollectorParams_SignType>(_impl_.sign_type_);
}
inline void CollectorParams::_internal_set_sign_type(::keyapis::telemetry_control::v1::CollectorParams_SignType value) {
  ;
  _impl_.sign_type_ = value;
}

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

// EICAllFiasStartTask

// .keyapis.telemetry_control.v1.CollectorParams collector_params = 1 [(.google.api.field_behavior) = REQUIRED];
inline bool EICAllFiasStartTask::has_collector_params() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.collector_params_ != nullptr);
  return value;
}
inline void EICAllFiasStartTask::clear_collector_params() {
  if (_impl_.collector_params_ != nullptr) _impl_.collector_params_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::keyapis::telemetry_control::v1::CollectorParams& EICAllFiasStartTask::_internal_collector_params() const {
  const ::keyapis::telemetry_control::v1::CollectorParams* p = _impl_.collector_params_;
  return p != nullptr ? *p : reinterpret_cast<const ::keyapis::telemetry_control::v1::CollectorParams&>(
      ::keyapis::telemetry_control::v1::_CollectorParams_default_instance_);
}
inline const ::keyapis::telemetry_control::v1::CollectorParams& EICAllFiasStartTask::collector_params() const {
  // @@protoc_insertion_point(field_get:keyapis.telemetry_control.v1.EICAllFiasStartTask.collector_params)
  return _internal_collector_params();
}
inline void EICAllFiasStartTask::unsafe_arena_set_allocated_collector_params(
    ::keyapis::telemetry_control::v1::CollectorParams* collector_params) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.collector_params_);
  }
  _impl_.collector_params_ = collector_params;
  if (collector_params) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:keyapis.telemetry_control.v1.EICAllFiasStartTask.collector_params)
}
inline ::keyapis::telemetry_control::v1::CollectorParams* EICAllFiasStartTask::release_collector_params() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::telemetry_control::v1::CollectorParams* temp = _impl_.collector_params_;
  _impl_.collector_params_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::keyapis::telemetry_control::v1::CollectorParams* EICAllFiasStartTask::unsafe_arena_release_collector_params() {
  // @@protoc_insertion_point(field_release:keyapis.telemetry_control.v1.EICAllFiasStartTask.collector_params)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::keyapis::telemetry_control::v1::CollectorParams* temp = _impl_.collector_params_;
  _impl_.collector_params_ = nullptr;
  return temp;
}
inline ::keyapis::telemetry_control::v1::CollectorParams* EICAllFiasStartTask::_internal_mutable_collector_params() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.collector_params_ == nullptr) {
    auto* p = CreateMaybeMessage<::keyapis::telemetry_control::v1::CollectorParams>(GetArenaForAllocation());
    _impl_.collector_params_ = p;
  }
  return _impl_.collector_params_;
}
inline ::keyapis::telemetry_control::v1::CollectorParams* EICAllFiasStartTask::mutable_collector_params() {
  ::keyapis::telemetry_control::v1::CollectorParams* _msg = _internal_mutable_collector_params();
  // @@protoc_insertion_point(field_mutable:keyapis.telemetry_control.v1.EICAllFiasStartTask.collector_params)
  return _msg;
}
inline void EICAllFiasStartTask::set_allocated_collector_params(::keyapis::telemetry_control::v1::CollectorParams* collector_params) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.collector_params_;
  }
  if (collector_params) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(collector_params);
    if (message_arena != submessage_arena) {
      collector_params = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, collector_params, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.collector_params_ = collector_params;
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.EICAllFiasStartTask.collector_params)
}

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis


PROTOBUF_NAMESPACE_OPEN

template <>
struct is_proto_enum<::keyapis::telemetry_control::v1::CollectorParams_SignType> : std::true_type {};
template <>
struct is_proto_enum<::keyapis::telemetry_control::v1::CollectorParams_ArchiveType> : std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_keyapis_2ftelemetry_5fcontrol_2fv1_2fkeyapis_5ftelemetry_5fcontrol_5fevents_5fv1_2eproto_2epb_2eh