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

#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fsecuregcm_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fsecuregcm_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fsecuregcm_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fsecuregcm_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
namespace securegcm {
class GcmDeviceInfo;
struct GcmDeviceInfoDefaultTypeInternal;
extern GcmDeviceInfoDefaultTypeInternal _GcmDeviceInfo_default_instance_;
class GcmMetadata;
struct GcmMetadataDefaultTypeInternal;
extern GcmMetadataDefaultTypeInternal _GcmMetadata_default_instance_;
class LoginNotificationInfo;
struct LoginNotificationInfoDefaultTypeInternal;
extern LoginNotificationInfoDefaultTypeInternal _LoginNotificationInfo_default_instance_;
class Tickle;
struct TickleDefaultTypeInternal;
extern TickleDefaultTypeInternal _Tickle_default_instance_;
}  // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> ::securegcm::GcmDeviceInfo* Arena::CreateMaybeMessage<::securegcm::GcmDeviceInfo>(Arena*);
template<> ::securegcm::GcmMetadata* Arena::CreateMaybeMessage<::securegcm::GcmMetadata>(Arena*);
template<> ::securegcm::LoginNotificationInfo* Arena::CreateMaybeMessage<::securegcm::LoginNotificationInfo>(Arena*);
template<> ::securegcm::Tickle* Arena::CreateMaybeMessage<::securegcm::Tickle>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace securegcm {

enum AppleDeviceDiagonalMils : int {
  APPLE_PHONE = 4000,
  APPLE_PAD = 7900
};
bool AppleDeviceDiagonalMils_IsValid(int value);
constexpr AppleDeviceDiagonalMils AppleDeviceDiagonalMils_MIN = APPLE_PHONE;
constexpr AppleDeviceDiagonalMils AppleDeviceDiagonalMils_MAX = APPLE_PAD;
constexpr int AppleDeviceDiagonalMils_ARRAYSIZE = AppleDeviceDiagonalMils_MAX + 1;

const std::string& AppleDeviceDiagonalMils_Name(AppleDeviceDiagonalMils value);
template<typename T>
inline const std::string& AppleDeviceDiagonalMils_Name(T enum_t_value) {
  static_assert(::std::is_same<T, AppleDeviceDiagonalMils>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function AppleDeviceDiagonalMils_Name.");
  return AppleDeviceDiagonalMils_Name(static_cast<AppleDeviceDiagonalMils>(enum_t_value));
}
bool AppleDeviceDiagonalMils_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AppleDeviceDiagonalMils* value);
enum DeviceType : int {
  UNKNOWN = 0,
  ANDROID = 1,
  CHROME = 2,
  IOS = 3,
  BROWSER = 4,
  OSX = 5
};
bool DeviceType_IsValid(int value);
constexpr DeviceType DeviceType_MIN = UNKNOWN;
constexpr DeviceType DeviceType_MAX = OSX;
constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;

const std::string& DeviceType_Name(DeviceType value);
template<typename T>
inline const std::string& DeviceType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceType_Name.");
  return DeviceType_Name(static_cast<DeviceType>(enum_t_value));
}
bool DeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value);
enum SoftwareFeature : int {
  UNKNOWN_FEATURE = 0,
  BETTER_TOGETHER_HOST = 1,
  BETTER_TOGETHER_CLIENT = 2,
  EASY_UNLOCK_HOST = 3,
  EASY_UNLOCK_CLIENT = 4,
  MAGIC_TETHER_HOST = 5,
  MAGIC_TETHER_CLIENT = 6,
  SMS_CONNECT_HOST = 7,
  SMS_CONNECT_CLIENT = 8
};
bool SoftwareFeature_IsValid(int value);
constexpr SoftwareFeature SoftwareFeature_MIN = UNKNOWN_FEATURE;
constexpr SoftwareFeature SoftwareFeature_MAX = SMS_CONNECT_CLIENT;
constexpr int SoftwareFeature_ARRAYSIZE = SoftwareFeature_MAX + 1;

const std::string& SoftwareFeature_Name(SoftwareFeature value);
template<typename T>
inline const std::string& SoftwareFeature_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SoftwareFeature>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SoftwareFeature_Name.");
  return SoftwareFeature_Name(static_cast<SoftwareFeature>(enum_t_value));
}
bool SoftwareFeature_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SoftwareFeature* value);
enum InvocationReason : int {
  REASON_UNKNOWN = 0,
  REASON_INITIALIZATION = 1,
  REASON_PERIODIC = 2,
  REASON_SLOW_PERIODIC = 3,
  REASON_FAST_PERIODIC = 4,
  REASON_EXPIRATION = 5,
  REASON_FAILURE_RECOVERY = 6,
  REASON_NEW_ACCOUNT = 7,
  REASON_CHANGED_ACCOUNT = 8,
  REASON_FEATURE_TOGGLED = 9,
  REASON_SERVER_INITIATED = 10,
  REASON_ADDRESS_CHANGE = 11,
  REASON_SOFTWARE_UPDATE = 12,
  REASON_MANUAL = 13,
  REASON_CUSTOM_KEY_INVALIDATION = 14,
  REASON_PROXIMITY_PERIODIC = 15
};
bool InvocationReason_IsValid(int value);
constexpr InvocationReason InvocationReason_MIN = REASON_UNKNOWN;
constexpr InvocationReason InvocationReason_MAX = REASON_PROXIMITY_PERIODIC;
constexpr int InvocationReason_ARRAYSIZE = InvocationReason_MAX + 1;

const std::string& InvocationReason_Name(InvocationReason value);
template<typename T>
inline const std::string& InvocationReason_Name(T enum_t_value) {
  static_assert(::std::is_same<T, InvocationReason>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function InvocationReason_Name.");
  return InvocationReason_Name(static_cast<InvocationReason>(enum_t_value));
}
bool InvocationReason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InvocationReason* value);
enum Type : int {
  ENROLLMENT = 0,
  TICKLE = 1,
  TX_REQUEST = 2,
  TX_REPLY = 3,
  TX_SYNC_REQUEST = 4,
  TX_SYNC_RESPONSE = 5,
  TX_PING = 6,
  DEVICE_INFO_UPDATE = 7,
  TX_CANCEL_REQUEST = 8,
  PROXIMITYAUTH_PAIRING = 10,
  GCMV1_IDENTITY_ASSERTION = 11,
  DEVICE_TO_DEVICE_RESPONDER_HELLO_PAYLOAD = 12,
  DEVICE_TO_DEVICE_MESSAGE = 13,
  DEVICE_PROXIMITY_CALLBACK = 14,
  UNLOCK_KEY_SIGNED_CHALLENGE = 15,
  LOGIN_NOTIFICATION = 101
};
bool Type_IsValid(int value);
constexpr Type Type_MIN = ENROLLMENT;
constexpr Type Type_MAX = LOGIN_NOTIFICATION;
constexpr int Type_ARRAYSIZE = Type_MAX + 1;

const std::string& Type_Name(Type value);
template<typename T>
inline const std::string& Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Type_Name.");
  return Type_Name(static_cast<Type>(enum_t_value));
}
bool Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type* value);
// ===================================================================

class GcmDeviceInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.GcmDeviceInfo) */ {
 public:
  inline GcmDeviceInfo() : GcmDeviceInfo(nullptr) {}
  ~GcmDeviceInfo() override;
  explicit constexpr GcmDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  friend void swap(GcmDeviceInfo& a, GcmDeviceInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(GcmDeviceInfo* 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(GcmDeviceInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GcmDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GcmDeviceInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GcmDeviceInfo& from);
  void MergeFrom(const GcmDeviceInfo& 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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GcmDeviceInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.GcmDeviceInfo";
  }
  protected:
  explicit GcmDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kSupportedSoftwareFeaturesFieldNumber = 411,
    kEnabledSoftwareFeaturesFieldNumber = 412,
    kUserPublicKeyFieldNumber = 4,
    kDeviceModelFieldNumber = 7,
    kLocaleFieldNumber = 8,
    kKeyHandleFieldNumber = 9,
    kDeviceOsVersionFieldNumber = 13,
    kDeviceOsReleaseFieldNumber = 15,
    kDeviceOsCodenameFieldNumber = 16,
    kDeviceSoftwareVersionFieldNumber = 17,
    kDeviceSoftwarePackageFieldNumber = 19,
    kLongDeviceIdFieldNumber = 29,
    kDeviceManufacturerFieldNumber = 31,
    kGcmRegistrationIdFieldNumber = 102,
    kDeviceMasterKeyHashFieldNumber = 103,
    kApnRegistrationIdFieldNumber = 202,
    kBluetoothMacAddressFieldNumber = 302,
    kEnrollmentSessionIdFieldNumber = 1000,
    kOauthTokenFieldNumber = 1001,
    kAndroidDeviceIdFieldNumber = 1,
    kCounterFieldNumber = 12,
    kDeviceOsVersionCodeFieldNumber = 14,
    kDeviceSoftwareVersionCodeFieldNumber = 18,
    kDeviceDisplayDiagonalMilsFieldNumber = 22,
    kDeviceAuthzenVersionFieldNumber = 24,
    kPixelExperienceFieldNumber = 408,
    kArcPlusPlusFieldNumber = 409,
    kIsScreenlockStateFlakyFieldNumber = 410,
    kUsingSecureScreenlockFieldNumber = 400,
    kAutoUnlockScreenlockSupportedFieldNumber = 401,
    kAutoUnlockScreenlockEnabledFieldNumber = 402,
    kBluetoothRadioSupportedFieldNumber = 403,
    kBluetoothRadioEnabledFieldNumber = 404,
    kMobileDataSupportedFieldNumber = 405,
    kTetheringSupportedFieldNumber = 406,
    kBleRadioSupportedFieldNumber = 407,
    kDeviceTypeFieldNumber = 32,
    kNotificationEnabledFieldNumber = 203,
  };
  // repeated .securegcm.SoftwareFeature supported_software_features = 411;
  int supported_software_features_size() const;
  private:
  int _internal_supported_software_features_size() const;
  public:
  void clear_supported_software_features();
  private:
  ::securegcm::SoftwareFeature _internal_supported_software_features(int index) const;
  void _internal_add_supported_software_features(::securegcm::SoftwareFeature value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_software_features();
  public:
  ::securegcm::SoftwareFeature supported_software_features(int index) const;
  void set_supported_software_features(int index, ::securegcm::SoftwareFeature value);
  void add_supported_software_features(::securegcm::SoftwareFeature value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_software_features() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_software_features();

  // repeated .securegcm.SoftwareFeature enabled_software_features = 412;
  int enabled_software_features_size() const;
  private:
  int _internal_enabled_software_features_size() const;
  public:
  void clear_enabled_software_features();
  private:
  ::securegcm::SoftwareFeature _internal_enabled_software_features(int index) const;
  void _internal_add_enabled_software_features(::securegcm::SoftwareFeature value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_enabled_software_features();
  public:
  ::securegcm::SoftwareFeature enabled_software_features(int index) const;
  void set_enabled_software_features(int index, ::securegcm::SoftwareFeature value);
  void add_enabled_software_features(::securegcm::SoftwareFeature value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& enabled_software_features() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_enabled_software_features();

  // required bytes user_public_key = 4;
  bool has_user_public_key() const;
  private:
  bool _internal_has_user_public_key() const;
  public:
  void clear_user_public_key();
  const std::string& user_public_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_user_public_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_user_public_key();
  PROTOBUF_NODISCARD std::string* release_user_public_key();
  void set_allocated_user_public_key(std::string* user_public_key);
  private:
  const std::string& _internal_user_public_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_user_public_key(const std::string& value);
  std::string* _internal_mutable_user_public_key();
  public:

  // optional string device_model = 7;
  bool has_device_model() const;
  private:
  bool _internal_has_device_model() const;
  public:
  void clear_device_model();
  const std::string& device_model() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_model(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_model();
  PROTOBUF_NODISCARD std::string* release_device_model();
  void set_allocated_device_model(std::string* device_model);
  private:
  const std::string& _internal_device_model() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model(const std::string& value);
  std::string* _internal_mutable_device_model();
  public:

  // optional string locale = 8;
  bool has_locale() const;
  private:
  bool _internal_has_locale() const;
  public:
  void clear_locale();
  const std::string& locale() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_locale(ArgT0&& arg0, ArgT... args);
  std::string* mutable_locale();
  PROTOBUF_NODISCARD std::string* release_locale();
  void set_allocated_locale(std::string* locale);
  private:
  const std::string& _internal_locale() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value);
  std::string* _internal_mutable_locale();
  public:

  // optional bytes key_handle = 9;
  bool has_key_handle() const;
  private:
  bool _internal_has_key_handle() const;
  public:
  void clear_key_handle();
  const std::string& key_handle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_handle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_handle();
  PROTOBUF_NODISCARD std::string* release_key_handle();
  void set_allocated_key_handle(std::string* key_handle);
  private:
  const std::string& _internal_key_handle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_handle(const std::string& value);
  std::string* _internal_mutable_key_handle();
  public:

  // optional string device_os_version = 13;
  bool has_device_os_version() const;
  private:
  bool _internal_has_device_os_version() const;
  public:
  void clear_device_os_version();
  const std::string& device_os_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_os_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_os_version();
  PROTOBUF_NODISCARD std::string* release_device_os_version();
  void set_allocated_device_os_version(std::string* device_os_version);
  private:
  const std::string& _internal_device_os_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_os_version(const std::string& value);
  std::string* _internal_mutable_device_os_version();
  public:

  // optional string device_os_release = 15;
  bool has_device_os_release() const;
  private:
  bool _internal_has_device_os_release() const;
  public:
  void clear_device_os_release();
  const std::string& device_os_release() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_os_release(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_os_release();
  PROTOBUF_NODISCARD std::string* release_device_os_release();
  void set_allocated_device_os_release(std::string* device_os_release);
  private:
  const std::string& _internal_device_os_release() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_os_release(const std::string& value);
  std::string* _internal_mutable_device_os_release();
  public:

  // optional string device_os_codename = 16;
  bool has_device_os_codename() const;
  private:
  bool _internal_has_device_os_codename() const;
  public:
  void clear_device_os_codename();
  const std::string& device_os_codename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_os_codename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_os_codename();
  PROTOBUF_NODISCARD std::string* release_device_os_codename();
  void set_allocated_device_os_codename(std::string* device_os_codename);
  private:
  const std::string& _internal_device_os_codename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_os_codename(const std::string& value);
  std::string* _internal_mutable_device_os_codename();
  public:

  // optional string device_software_version = 17;
  bool has_device_software_version() const;
  private:
  bool _internal_has_device_software_version() const;
  public:
  void clear_device_software_version();
  const std::string& device_software_version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_software_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_software_version();
  PROTOBUF_NODISCARD std::string* release_device_software_version();
  void set_allocated_device_software_version(std::string* device_software_version);
  private:
  const std::string& _internal_device_software_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_software_version(const std::string& value);
  std::string* _internal_mutable_device_software_version();
  public:

  // optional string device_software_package = 19;
  bool has_device_software_package() const;
  private:
  bool _internal_has_device_software_package() const;
  public:
  void clear_device_software_package();
  const std::string& device_software_package() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_software_package(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_software_package();
  PROTOBUF_NODISCARD std::string* release_device_software_package();
  void set_allocated_device_software_package(std::string* device_software_package);
  private:
  const std::string& _internal_device_software_package() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_software_package(const std::string& value);
  std::string* _internal_mutable_device_software_package();
  public:

  // optional bytes long_device_id = 29;
  bool has_long_device_id() const;
  private:
  bool _internal_has_long_device_id() const;
  public:
  void clear_long_device_id();
  const std::string& long_device_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_long_device_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_long_device_id();
  PROTOBUF_NODISCARD std::string* release_long_device_id();
  void set_allocated_long_device_id(std::string* long_device_id);
  private:
  const std::string& _internal_long_device_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_long_device_id(const std::string& value);
  std::string* _internal_mutable_long_device_id();
  public:

  // optional string device_manufacturer = 31;
  bool has_device_manufacturer() const;
  private:
  bool _internal_has_device_manufacturer() const;
  public:
  void clear_device_manufacturer();
  const std::string& device_manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_manufacturer();
  PROTOBUF_NODISCARD std::string* release_device_manufacturer();
  void set_allocated_device_manufacturer(std::string* device_manufacturer);
  private:
  const std::string& _internal_device_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_manufacturer(const std::string& value);
  std::string* _internal_mutable_device_manufacturer();
  public:

  // optional bytes gcm_registration_id = 102;
  bool has_gcm_registration_id() const;
  private:
  bool _internal_has_gcm_registration_id() const;
  public:
  void clear_gcm_registration_id();
  const std::string& gcm_registration_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gcm_registration_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gcm_registration_id();
  PROTOBUF_NODISCARD std::string* release_gcm_registration_id();
  void set_allocated_gcm_registration_id(std::string* gcm_registration_id);
  private:
  const std::string& _internal_gcm_registration_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gcm_registration_id(const std::string& value);
  std::string* _internal_mutable_gcm_registration_id();
  public:

  // optional bytes device_master_key_hash = 103;
  bool has_device_master_key_hash() const;
  private:
  bool _internal_has_device_master_key_hash() const;
  public:
  void clear_device_master_key_hash();
  const std::string& device_master_key_hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device_master_key_hash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device_master_key_hash();
  PROTOBUF_NODISCARD std::string* release_device_master_key_hash();
  void set_allocated_device_master_key_hash(std::string* device_master_key_hash);
  private:
  const std::string& _internal_device_master_key_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_master_key_hash(const std::string& value);
  std::string* _internal_mutable_device_master_key_hash();
  public:

  // optional bytes apn_registration_id = 202;
  bool has_apn_registration_id() const;
  private:
  bool _internal_has_apn_registration_id() const;
  public:
  void clear_apn_registration_id();
  const std::string& apn_registration_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_apn_registration_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_apn_registration_id();
  PROTOBUF_NODISCARD std::string* release_apn_registration_id();
  void set_allocated_apn_registration_id(std::string* apn_registration_id);
  private:
  const std::string& _internal_apn_registration_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_apn_registration_id(const std::string& value);
  std::string* _internal_mutable_apn_registration_id();
  public:

  // optional string bluetooth_mac_address = 302;
  bool has_bluetooth_mac_address() const;
  private:
  bool _internal_has_bluetooth_mac_address() const;
  public:
  void clear_bluetooth_mac_address();
  const std::string& bluetooth_mac_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bluetooth_mac_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bluetooth_mac_address();
  PROTOBUF_NODISCARD std::string* release_bluetooth_mac_address();
  void set_allocated_bluetooth_mac_address(std::string* bluetooth_mac_address);
  private:
  const std::string& _internal_bluetooth_mac_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bluetooth_mac_address(const std::string& value);
  std::string* _internal_mutable_bluetooth_mac_address();
  public:

  // optional bytes enrollment_session_id = 1000;
  bool has_enrollment_session_id() const;
  private:
  bool _internal_has_enrollment_session_id() const;
  public:
  void clear_enrollment_session_id();
  const std::string& enrollment_session_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enrollment_session_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enrollment_session_id();
  PROTOBUF_NODISCARD std::string* release_enrollment_session_id();
  void set_allocated_enrollment_session_id(std::string* enrollment_session_id);
  private:
  const std::string& _internal_enrollment_session_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enrollment_session_id(const std::string& value);
  std::string* _internal_mutable_enrollment_session_id();
  public:

  // optional string oauth_token = 1001;
  bool has_oauth_token() const;
  private:
  bool _internal_has_oauth_token() const;
  public:
  void clear_oauth_token();
  const std::string& oauth_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oauth_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oauth_token();
  PROTOBUF_NODISCARD std::string* release_oauth_token();
  void set_allocated_oauth_token(std::string* oauth_token);
  private:
  const std::string& _internal_oauth_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oauth_token(const std::string& value);
  std::string* _internal_mutable_oauth_token();
  public:

  // optional fixed64 android_device_id = 1;
  bool has_android_device_id() const;
  private:
  bool _internal_has_android_device_id() const;
  public:
  void clear_android_device_id();
  uint64_t android_device_id() const;
  void set_android_device_id(uint64_t value);
  private:
  uint64_t _internal_android_device_id() const;
  void _internal_set_android_device_id(uint64_t value);
  public:

  // optional int64 counter = 12 [default = 0];
  bool has_counter() const;
  private:
  bool _internal_has_counter() const;
  public:
  void clear_counter();
  int64_t counter() const;
  void set_counter(int64_t value);
  private:
  int64_t _internal_counter() const;
  void _internal_set_counter(int64_t value);
  public:

  // optional int64 device_os_version_code = 14;
  bool has_device_os_version_code() const;
  private:
  bool _internal_has_device_os_version_code() const;
  public:
  void clear_device_os_version_code();
  int64_t device_os_version_code() const;
  void set_device_os_version_code(int64_t value);
  private:
  int64_t _internal_device_os_version_code() const;
  void _internal_set_device_os_version_code(int64_t value);
  public:

  // optional int64 device_software_version_code = 18;
  bool has_device_software_version_code() const;
  private:
  bool _internal_has_device_software_version_code() const;
  public:
  void clear_device_software_version_code();
  int64_t device_software_version_code() const;
  void set_device_software_version_code(int64_t value);
  private:
  int64_t _internal_device_software_version_code() const;
  void _internal_set_device_software_version_code(int64_t value);
  public:

  // optional int32 device_display_diagonal_mils = 22;
  bool has_device_display_diagonal_mils() const;
  private:
  bool _internal_has_device_display_diagonal_mils() const;
  public:
  void clear_device_display_diagonal_mils();
  int32_t device_display_diagonal_mils() const;
  void set_device_display_diagonal_mils(int32_t value);
  private:
  int32_t _internal_device_display_diagonal_mils() const;
  void _internal_set_device_display_diagonal_mils(int32_t value);
  public:

  // optional int32 device_authzen_version = 24;
  bool has_device_authzen_version() const;
  private:
  bool _internal_has_device_authzen_version() const;
  public:
  void clear_device_authzen_version();
  int32_t device_authzen_version() const;
  void set_device_authzen_version(int32_t value);
  private:
  int32_t _internal_device_authzen_version() const;
  void _internal_set_device_authzen_version(int32_t value);
  public:

  // optional bool pixel_experience = 408 [default = false];
  bool has_pixel_experience() const;
  private:
  bool _internal_has_pixel_experience() const;
  public:
  void clear_pixel_experience();
  bool pixel_experience() const;
  void set_pixel_experience(bool value);
  private:
  bool _internal_pixel_experience() const;
  void _internal_set_pixel_experience(bool value);
  public:

  // optional bool arc_plus_plus = 409 [default = false];
  bool has_arc_plus_plus() const;
  private:
  bool _internal_has_arc_plus_plus() const;
  public:
  void clear_arc_plus_plus();
  bool arc_plus_plus() const;
  void set_arc_plus_plus(bool value);
  private:
  bool _internal_arc_plus_plus() const;
  void _internal_set_arc_plus_plus(bool value);
  public:

  // optional bool is_screenlock_state_flaky = 410 [default = false];
  bool has_is_screenlock_state_flaky() const;
  private:
  bool _internal_has_is_screenlock_state_flaky() const;
  public:
  void clear_is_screenlock_state_flaky();
  bool is_screenlock_state_flaky() const;
  void set_is_screenlock_state_flaky(bool value);
  private:
  bool _internal_is_screenlock_state_flaky() const;
  void _internal_set_is_screenlock_state_flaky(bool value);
  public:

  // optional bool using_secure_screenlock = 400 [default = false];
  bool has_using_secure_screenlock() const;
  private:
  bool _internal_has_using_secure_screenlock() const;
  public:
  void clear_using_secure_screenlock();
  bool using_secure_screenlock() const;
  void set_using_secure_screenlock(bool value);
  private:
  bool _internal_using_secure_screenlock() const;
  void _internal_set_using_secure_screenlock(bool value);
  public:

  // optional bool auto_unlock_screenlock_supported = 401 [default = false];
  bool has_auto_unlock_screenlock_supported() const;
  private:
  bool _internal_has_auto_unlock_screenlock_supported() const;
  public:
  void clear_auto_unlock_screenlock_supported();
  bool auto_unlock_screenlock_supported() const;
  void set_auto_unlock_screenlock_supported(bool value);
  private:
  bool _internal_auto_unlock_screenlock_supported() const;
  void _internal_set_auto_unlock_screenlock_supported(bool value);
  public:

  // optional bool auto_unlock_screenlock_enabled = 402 [default = false];
  bool has_auto_unlock_screenlock_enabled() const;
  private:
  bool _internal_has_auto_unlock_screenlock_enabled() const;
  public:
  void clear_auto_unlock_screenlock_enabled();
  bool auto_unlock_screenlock_enabled() const;
  void set_auto_unlock_screenlock_enabled(bool value);
  private:
  bool _internal_auto_unlock_screenlock_enabled() const;
  void _internal_set_auto_unlock_screenlock_enabled(bool value);
  public:

  // optional bool bluetooth_radio_supported = 403 [default = false];
  bool has_bluetooth_radio_supported() const;
  private:
  bool _internal_has_bluetooth_radio_supported() const;
  public:
  void clear_bluetooth_radio_supported();
  bool bluetooth_radio_supported() const;
  void set_bluetooth_radio_supported(bool value);
  private:
  bool _internal_bluetooth_radio_supported() const;
  void _internal_set_bluetooth_radio_supported(bool value);
  public:

  // optional bool bluetooth_radio_enabled = 404 [default = false];
  bool has_bluetooth_radio_enabled() const;
  private:
  bool _internal_has_bluetooth_radio_enabled() const;
  public:
  void clear_bluetooth_radio_enabled();
  bool bluetooth_radio_enabled() const;
  void set_bluetooth_radio_enabled(bool value);
  private:
  bool _internal_bluetooth_radio_enabled() const;
  void _internal_set_bluetooth_radio_enabled(bool value);
  public:

  // optional bool mobile_data_supported = 405 [default = false];
  bool has_mobile_data_supported() const;
  private:
  bool _internal_has_mobile_data_supported() const;
  public:
  void clear_mobile_data_supported();
  bool mobile_data_supported() const;
  void set_mobile_data_supported(bool value);
  private:
  bool _internal_mobile_data_supported() const;
  void _internal_set_mobile_data_supported(bool value);
  public:

  // optional bool tethering_supported = 406 [default = false];
  bool has_tethering_supported() const;
  private:
  bool _internal_has_tethering_supported() const;
  public:
  void clear_tethering_supported();
  bool tethering_supported() const;
  void set_tethering_supported(bool value);
  private:
  bool _internal_tethering_supported() const;
  void _internal_set_tethering_supported(bool value);
  public:

  // optional bool ble_radio_supported = 407 [default = false];
  bool has_ble_radio_supported() const;
  private:
  bool _internal_has_ble_radio_supported() const;
  public:
  void clear_ble_radio_supported();
  bool ble_radio_supported() const;
  void set_ble_radio_supported(bool value);
  private:
  bool _internal_ble_radio_supported() const;
  void _internal_set_ble_radio_supported(bool value);
  public:

  // optional .securegcm.DeviceType device_type = 32 [default = ANDROID];
  bool has_device_type() const;
  private:
  bool _internal_has_device_type() const;
  public:
  void clear_device_type();
  ::securegcm::DeviceType device_type() const;
  void set_device_type(::securegcm::DeviceType value);
  private:
  ::securegcm::DeviceType _internal_device_type() const;
  void _internal_set_device_type(::securegcm::DeviceType value);
  public:

  // optional bool notification_enabled = 203 [default = true];
  bool has_notification_enabled() const;
  private:
  bool _internal_has_notification_enabled() const;
  public:
  void clear_notification_enabled();
  bool notification_enabled() const;
  void set_notification_enabled(bool value);
  private:
  bool _internal_notification_enabled() const;
  void _internal_set_notification_enabled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.GcmDeviceInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_software_features_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> enabled_software_features_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr user_public_key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr locale_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_handle_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_os_version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_os_release_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_os_codename_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_software_version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_software_package_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr long_device_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_manufacturer_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gcm_registration_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_master_key_hash_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr apn_registration_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bluetooth_mac_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enrollment_session_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oauth_token_;
  uint64_t android_device_id_;
  int64_t counter_;
  int64_t device_os_version_code_;
  int64_t device_software_version_code_;
  int32_t device_display_diagonal_mils_;
  int32_t device_authzen_version_;
  bool pixel_experience_;
  bool arc_plus_plus_;
  bool is_screenlock_state_flaky_;
  bool using_secure_screenlock_;
  bool auto_unlock_screenlock_supported_;
  bool auto_unlock_screenlock_enabled_;
  bool bluetooth_radio_supported_;
  bool bluetooth_radio_enabled_;
  bool mobile_data_supported_;
  bool tethering_supported_;
  bool ble_radio_supported_;
  int device_type_;
  bool notification_enabled_;
  friend struct ::TableStruct_proto_2fsecuregcm_2eproto;
};
// -------------------------------------------------------------------

class GcmMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.GcmMetadata) */ {
 public:
  inline GcmMetadata() : GcmMetadata(nullptr) {}
  ~GcmMetadata() override;
  explicit constexpr GcmMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  friend void swap(GcmMetadata& a, GcmMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(GcmMetadata* 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(GcmMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  GcmMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GcmMetadata>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const GcmMetadata& from);
  void MergeFrom(const GcmMetadata& 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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GcmMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.GcmMetadata";
  }
  protected:
  explicit GcmMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kTypeFieldNumber = 1,
    kVersionFieldNumber = 2,
  };
  // required .securegcm.Type type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::securegcm::Type type() const;
  void set_type(::securegcm::Type value);
  private:
  ::securegcm::Type _internal_type() const;
  void _internal_set_type(::securegcm::Type value);
  public:

  // optional int32 version = 2 [default = 0];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.GcmMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int type_;
  int32_t version_;
  friend struct ::TableStruct_proto_2fsecuregcm_2eproto;
};
// -------------------------------------------------------------------

class Tickle final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.Tickle) */ {
 public:
  inline Tickle() : Tickle(nullptr) {}
  ~Tickle() override;
  explicit constexpr Tickle(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  friend void swap(Tickle& a, Tickle& b) {
    a.Swap(&b);
  }
  inline void Swap(Tickle* 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(Tickle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Tickle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Tickle>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Tickle& from);
  void MergeFrom(const Tickle& 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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Tickle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.Tickle";
  }
  protected:
  explicit Tickle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kExpiryTimeFieldNumber = 1,
  };
  // optional fixed64 expiry_time = 1;
  bool has_expiry_time() const;
  private:
  bool _internal_has_expiry_time() const;
  public:
  void clear_expiry_time();
  uint64_t expiry_time() const;
  void set_expiry_time(uint64_t value);
  private:
  uint64_t _internal_expiry_time() const;
  void _internal_set_expiry_time(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.Tickle)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint64_t expiry_time_;
  friend struct ::TableStruct_proto_2fsecuregcm_2eproto;
};
// -------------------------------------------------------------------

class LoginNotificationInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.LoginNotificationInfo) */ {
 public:
  inline LoginNotificationInfo() : LoginNotificationInfo(nullptr) {}
  ~LoginNotificationInfo() override;
  explicit constexpr LoginNotificationInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  friend void swap(LoginNotificationInfo& a, LoginNotificationInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(LoginNotificationInfo* 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(LoginNotificationInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LoginNotificationInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LoginNotificationInfo>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const LoginNotificationInfo& from);
  void MergeFrom(const LoginNotificationInfo& 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 _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoginNotificationInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "securegcm.LoginNotificationInfo";
  }
  protected:
  explicit LoginNotificationInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEmailFieldNumber = 3,
    kHostFieldNumber = 4,
    kSourceFieldNumber = 5,
    kEventTypeFieldNumber = 6,
    kCreationTimeFieldNumber = 2,
  };
  // optional string email = 3;
  bool has_email() const;
  private:
  bool _internal_has_email() const;
  public:
  void clear_email();
  const std::string& email() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_email(ArgT0&& arg0, ArgT... args);
  std::string* mutable_email();
  PROTOBUF_NODISCARD std::string* release_email();
  void set_allocated_email(std::string* email);
  private:
  const std::string& _internal_email() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_email(const std::string& value);
  std::string* _internal_mutable_email();
  public:

  // optional string host = 4;
  bool has_host() const;
  private:
  bool _internal_has_host() const;
  public:
  void clear_host();
  const std::string& host() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_host(ArgT0&& arg0, ArgT... args);
  std::string* mutable_host();
  PROTOBUF_NODISCARD std::string* release_host();
  void set_allocated_host(std::string* host);
  private:
  const std::string& _internal_host() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_host(const std::string& value);
  std::string* _internal_mutable_host();
  public:

  // optional string source = 5;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string event_type = 6;
  bool has_event_type() const;
  private:
  bool _internal_has_event_type() const;
  public:
  void clear_event_type();
  const std::string& event_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_event_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_event_type();
  PROTOBUF_NODISCARD std::string* release_event_type();
  void set_allocated_event_type(std::string* event_type);
  private:
  const std::string& _internal_event_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_event_type(const std::string& value);
  std::string* _internal_mutable_event_type();
  public:

  // optional fixed64 creation_time = 2;
  bool has_creation_time() const;
  private:
  bool _internal_has_creation_time() const;
  public:
  void clear_creation_time();
  uint64_t creation_time() const;
  void set_creation_time(uint64_t value);
  private:
  uint64_t _internal_creation_time() const;
  void _internal_set_creation_time(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:securegcm.LoginNotificationInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr email_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr event_type_;
  uint64_t creation_time_;
  friend struct ::TableStruct_proto_2fsecuregcm_2eproto;
};
// ===================================================================


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

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

// optional fixed64 android_device_id = 1;
inline bool GcmDeviceInfo::_internal_has_android_device_id() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_android_device_id() const {
  return _internal_has_android_device_id();
}
inline void GcmDeviceInfo::clear_android_device_id() {
  android_device_id_ = uint64_t{0u};
  _has_bits_[0] &= ~0x00020000u;
}
inline uint64_t GcmDeviceInfo::_internal_android_device_id() const {
  return android_device_id_;
}
inline uint64_t GcmDeviceInfo::android_device_id() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.android_device_id)
  return _internal_android_device_id();
}
inline void GcmDeviceInfo::_internal_set_android_device_id(uint64_t value) {
  _has_bits_[0] |= 0x00020000u;
  android_device_id_ = value;
}
inline void GcmDeviceInfo::set_android_device_id(uint64_t value) {
  _internal_set_android_device_id(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.android_device_id)
}

// optional bytes gcm_registration_id = 102;
inline bool GcmDeviceInfo::_internal_has_gcm_registration_id() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_gcm_registration_id() const {
  return _internal_has_gcm_registration_id();
}
inline void GcmDeviceInfo::clear_gcm_registration_id() {
  gcm_registration_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000800u;
}
inline const std::string& GcmDeviceInfo::gcm_registration_id() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.gcm_registration_id)
  return _internal_gcm_registration_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_gcm_registration_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000800u;
 gcm_registration_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.gcm_registration_id)
}
inline std::string* GcmDeviceInfo::mutable_gcm_registration_id() {
  std::string* _s = _internal_mutable_gcm_registration_id();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.gcm_registration_id)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_gcm_registration_id() const {
  return gcm_registration_id_.Get();
}
inline void GcmDeviceInfo::_internal_set_gcm_registration_id(const std::string& value) {
  _has_bits_[0] |= 0x00000800u;
  gcm_registration_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_gcm_registration_id() {
  _has_bits_[0] |= 0x00000800u;
  return gcm_registration_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_gcm_registration_id() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.gcm_registration_id)
  if (!_internal_has_gcm_registration_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000800u;
  auto* p = gcm_registration_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (gcm_registration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    gcm_registration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_gcm_registration_id(std::string* gcm_registration_id) {
  if (gcm_registration_id != nullptr) {
    _has_bits_[0] |= 0x00000800u;
  } else {
    _has_bits_[0] &= ~0x00000800u;
  }
  gcm_registration_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), gcm_registration_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (gcm_registration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    gcm_registration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.gcm_registration_id)
}

// optional bytes apn_registration_id = 202;
inline bool GcmDeviceInfo::_internal_has_apn_registration_id() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_apn_registration_id() const {
  return _internal_has_apn_registration_id();
}
inline void GcmDeviceInfo::clear_apn_registration_id() {
  apn_registration_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00002000u;
}
inline const std::string& GcmDeviceInfo::apn_registration_id() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.apn_registration_id)
  return _internal_apn_registration_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_apn_registration_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00002000u;
 apn_registration_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.apn_registration_id)
}
inline std::string* GcmDeviceInfo::mutable_apn_registration_id() {
  std::string* _s = _internal_mutable_apn_registration_id();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.apn_registration_id)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_apn_registration_id() const {
  return apn_registration_id_.Get();
}
inline void GcmDeviceInfo::_internal_set_apn_registration_id(const std::string& value) {
  _has_bits_[0] |= 0x00002000u;
  apn_registration_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_apn_registration_id() {
  _has_bits_[0] |= 0x00002000u;
  return apn_registration_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_apn_registration_id() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.apn_registration_id)
  if (!_internal_has_apn_registration_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00002000u;
  auto* p = apn_registration_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (apn_registration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    apn_registration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_apn_registration_id(std::string* apn_registration_id) {
  if (apn_registration_id != nullptr) {
    _has_bits_[0] |= 0x00002000u;
  } else {
    _has_bits_[0] &= ~0x00002000u;
  }
  apn_registration_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), apn_registration_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (apn_registration_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    apn_registration_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.apn_registration_id)
}

// optional bool notification_enabled = 203 [default = true];
inline bool GcmDeviceInfo::_internal_has_notification_enabled() const {
  bool value = (_has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_notification_enabled() const {
  return _internal_has_notification_enabled();
}
inline void GcmDeviceInfo::clear_notification_enabled() {
  notification_enabled_ = true;
  _has_bits_[1] &= ~0x00000008u;
}
inline bool GcmDeviceInfo::_internal_notification_enabled() const {
  return notification_enabled_;
}
inline bool GcmDeviceInfo::notification_enabled() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.notification_enabled)
  return _internal_notification_enabled();
}
inline void GcmDeviceInfo::_internal_set_notification_enabled(bool value) {
  _has_bits_[1] |= 0x00000008u;
  notification_enabled_ = value;
}
inline void GcmDeviceInfo::set_notification_enabled(bool value) {
  _internal_set_notification_enabled(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.notification_enabled)
}

// optional string bluetooth_mac_address = 302;
inline bool GcmDeviceInfo::_internal_has_bluetooth_mac_address() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_bluetooth_mac_address() const {
  return _internal_has_bluetooth_mac_address();
}
inline void GcmDeviceInfo::clear_bluetooth_mac_address() {
  bluetooth_mac_address_.ClearToEmpty();
  _has_bits_[0] &= ~0x00004000u;
}
inline const std::string& GcmDeviceInfo::bluetooth_mac_address() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.bluetooth_mac_address)
  return _internal_bluetooth_mac_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_bluetooth_mac_address(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00004000u;
 bluetooth_mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.bluetooth_mac_address)
}
inline std::string* GcmDeviceInfo::mutable_bluetooth_mac_address() {
  std::string* _s = _internal_mutable_bluetooth_mac_address();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.bluetooth_mac_address)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_bluetooth_mac_address() const {
  return bluetooth_mac_address_.Get();
}
inline void GcmDeviceInfo::_internal_set_bluetooth_mac_address(const std::string& value) {
  _has_bits_[0] |= 0x00004000u;
  bluetooth_mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_bluetooth_mac_address() {
  _has_bits_[0] |= 0x00004000u;
  return bluetooth_mac_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_bluetooth_mac_address() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.bluetooth_mac_address)
  if (!_internal_has_bluetooth_mac_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00004000u;
  auto* p = bluetooth_mac_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (bluetooth_mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    bluetooth_mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_bluetooth_mac_address(std::string* bluetooth_mac_address) {
  if (bluetooth_mac_address != nullptr) {
    _has_bits_[0] |= 0x00004000u;
  } else {
    _has_bits_[0] &= ~0x00004000u;
  }
  bluetooth_mac_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bluetooth_mac_address,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (bluetooth_mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    bluetooth_mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.bluetooth_mac_address)
}

// optional bytes device_master_key_hash = 103;
inline bool GcmDeviceInfo::_internal_has_device_master_key_hash() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_master_key_hash() const {
  return _internal_has_device_master_key_hash();
}
inline void GcmDeviceInfo::clear_device_master_key_hash() {
  device_master_key_hash_.ClearToEmpty();
  _has_bits_[0] &= ~0x00001000u;
}
inline const std::string& GcmDeviceInfo::device_master_key_hash() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_master_key_hash)
  return _internal_device_master_key_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_master_key_hash(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00001000u;
 device_master_key_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_master_key_hash)
}
inline std::string* GcmDeviceInfo::mutable_device_master_key_hash() {
  std::string* _s = _internal_mutable_device_master_key_hash();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_master_key_hash)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_master_key_hash() const {
  return device_master_key_hash_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_master_key_hash(const std::string& value) {
  _has_bits_[0] |= 0x00001000u;
  device_master_key_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_master_key_hash() {
  _has_bits_[0] |= 0x00001000u;
  return device_master_key_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_master_key_hash() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_master_key_hash)
  if (!_internal_has_device_master_key_hash()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00001000u;
  auto* p = device_master_key_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_master_key_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_master_key_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_master_key_hash(std::string* device_master_key_hash) {
  if (device_master_key_hash != nullptr) {
    _has_bits_[0] |= 0x00001000u;
  } else {
    _has_bits_[0] &= ~0x00001000u;
  }
  device_master_key_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_master_key_hash,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_master_key_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_master_key_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_master_key_hash)
}

// required bytes user_public_key = 4;
inline bool GcmDeviceInfo::_internal_has_user_public_key() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_user_public_key() const {
  return _internal_has_user_public_key();
}
inline void GcmDeviceInfo::clear_user_public_key() {
  user_public_key_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GcmDeviceInfo::user_public_key() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.user_public_key)
  return _internal_user_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_user_public_key(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 user_public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.user_public_key)
}
inline std::string* GcmDeviceInfo::mutable_user_public_key() {
  std::string* _s = _internal_mutable_user_public_key();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.user_public_key)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_user_public_key() const {
  return user_public_key_.Get();
}
inline void GcmDeviceInfo::_internal_set_user_public_key(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  user_public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_user_public_key() {
  _has_bits_[0] |= 0x00000001u;
  return user_public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_user_public_key() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.user_public_key)
  if (!_internal_has_user_public_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = user_public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (user_public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    user_public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_user_public_key(std::string* user_public_key) {
  if (user_public_key != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  user_public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), user_public_key,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (user_public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    user_public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.user_public_key)
}

// optional string device_model = 7;
inline bool GcmDeviceInfo::_internal_has_device_model() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_model() const {
  return _internal_has_device_model();
}
inline void GcmDeviceInfo::clear_device_model() {
  device_model_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& GcmDeviceInfo::device_model() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_model)
  return _internal_device_model();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_model(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_model)
}
inline std::string* GcmDeviceInfo::mutable_device_model() {
  std::string* _s = _internal_mutable_device_model();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_model)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_model() const {
  return device_model_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_model(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_model() {
  _has_bits_[0] |= 0x00000002u;
  return device_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_model() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_model)
  if (!_internal_has_device_model()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = device_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_model_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_model_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_model(std::string* device_model) {
  if (device_model != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  device_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_model_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_model_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_model)
}

// optional string locale = 8;
inline bool GcmDeviceInfo::_internal_has_locale() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_locale() const {
  return _internal_has_locale();
}
inline void GcmDeviceInfo::clear_locale() {
  locale_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& GcmDeviceInfo::locale() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.locale)
  return _internal_locale();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_locale(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 locale_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.locale)
}
inline std::string* GcmDeviceInfo::mutable_locale() {
  std::string* _s = _internal_mutable_locale();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.locale)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_locale() const {
  return locale_.Get();
}
inline void GcmDeviceInfo::_internal_set_locale(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  locale_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_locale() {
  _has_bits_[0] |= 0x00000004u;
  return locale_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_locale() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.locale)
  if (!_internal_has_locale()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = locale_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (locale_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    locale_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_locale(std::string* locale) {
  if (locale != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  locale_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), locale,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (locale_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    locale_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.locale)
}

// optional bytes key_handle = 9;
inline bool GcmDeviceInfo::_internal_has_key_handle() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_key_handle() const {
  return _internal_has_key_handle();
}
inline void GcmDeviceInfo::clear_key_handle() {
  key_handle_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& GcmDeviceInfo::key_handle() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.key_handle)
  return _internal_key_handle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_key_handle(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 key_handle_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.key_handle)
}
inline std::string* GcmDeviceInfo::mutable_key_handle() {
  std::string* _s = _internal_mutable_key_handle();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.key_handle)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_key_handle() const {
  return key_handle_.Get();
}
inline void GcmDeviceInfo::_internal_set_key_handle(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  key_handle_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_key_handle() {
  _has_bits_[0] |= 0x00000008u;
  return key_handle_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_key_handle() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.key_handle)
  if (!_internal_has_key_handle()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  auto* p = key_handle_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (key_handle_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    key_handle_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_key_handle(std::string* key_handle) {
  if (key_handle != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  key_handle_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_handle,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (key_handle_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    key_handle_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.key_handle)
}

// optional int64 counter = 12 [default = 0];
inline bool GcmDeviceInfo::_internal_has_counter() const {
  bool value = (_has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_counter() const {
  return _internal_has_counter();
}
inline void GcmDeviceInfo::clear_counter() {
  counter_ = int64_t{0};
  _has_bits_[0] &= ~0x00040000u;
}
inline int64_t GcmDeviceInfo::_internal_counter() const {
  return counter_;
}
inline int64_t GcmDeviceInfo::counter() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.counter)
  return _internal_counter();
}
inline void GcmDeviceInfo::_internal_set_counter(int64_t value) {
  _has_bits_[0] |= 0x00040000u;
  counter_ = value;
}
inline void GcmDeviceInfo::set_counter(int64_t value) {
  _internal_set_counter(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.counter)
}

// optional string device_os_version = 13;
inline bool GcmDeviceInfo::_internal_has_device_os_version() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_os_version() const {
  return _internal_has_device_os_version();
}
inline void GcmDeviceInfo::clear_device_os_version() {
  device_os_version_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& GcmDeviceInfo::device_os_version() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_os_version)
  return _internal_device_os_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_os_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000010u;
 device_os_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_os_version)
}
inline std::string* GcmDeviceInfo::mutable_device_os_version() {
  std::string* _s = _internal_mutable_device_os_version();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_os_version)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_os_version() const {
  return device_os_version_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_os_version(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  device_os_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_os_version() {
  _has_bits_[0] |= 0x00000010u;
  return device_os_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_os_version() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_os_version)
  if (!_internal_has_device_os_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  auto* p = device_os_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_os_version(std::string* device_os_version) {
  if (device_os_version != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  device_os_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_os_version,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_os_version)
}

// optional int64 device_os_version_code = 14;
inline bool GcmDeviceInfo::_internal_has_device_os_version_code() const {
  bool value = (_has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_os_version_code() const {
  return _internal_has_device_os_version_code();
}
inline void GcmDeviceInfo::clear_device_os_version_code() {
  device_os_version_code_ = int64_t{0};
  _has_bits_[0] &= ~0x00080000u;
}
inline int64_t GcmDeviceInfo::_internal_device_os_version_code() const {
  return device_os_version_code_;
}
inline int64_t GcmDeviceInfo::device_os_version_code() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_os_version_code)
  return _internal_device_os_version_code();
}
inline void GcmDeviceInfo::_internal_set_device_os_version_code(int64_t value) {
  _has_bits_[0] |= 0x00080000u;
  device_os_version_code_ = value;
}
inline void GcmDeviceInfo::set_device_os_version_code(int64_t value) {
  _internal_set_device_os_version_code(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_os_version_code)
}

// optional string device_os_release = 15;
inline bool GcmDeviceInfo::_internal_has_device_os_release() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_os_release() const {
  return _internal_has_device_os_release();
}
inline void GcmDeviceInfo::clear_device_os_release() {
  device_os_release_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& GcmDeviceInfo::device_os_release() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_os_release)
  return _internal_device_os_release();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_os_release(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000020u;
 device_os_release_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_os_release)
}
inline std::string* GcmDeviceInfo::mutable_device_os_release() {
  std::string* _s = _internal_mutable_device_os_release();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_os_release)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_os_release() const {
  return device_os_release_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_os_release(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  device_os_release_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_os_release() {
  _has_bits_[0] |= 0x00000020u;
  return device_os_release_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_os_release() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_os_release)
  if (!_internal_has_device_os_release()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  auto* p = device_os_release_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_release_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_os_release(std::string* device_os_release) {
  if (device_os_release != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  device_os_release_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_os_release,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_release_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_os_release)
}

// optional string device_os_codename = 16;
inline bool GcmDeviceInfo::_internal_has_device_os_codename() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_os_codename() const {
  return _internal_has_device_os_codename();
}
inline void GcmDeviceInfo::clear_device_os_codename() {
  device_os_codename_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& GcmDeviceInfo::device_os_codename() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_os_codename)
  return _internal_device_os_codename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_os_codename(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000040u;
 device_os_codename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_os_codename)
}
inline std::string* GcmDeviceInfo::mutable_device_os_codename() {
  std::string* _s = _internal_mutable_device_os_codename();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_os_codename)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_os_codename() const {
  return device_os_codename_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_os_codename(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  device_os_codename_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_os_codename() {
  _has_bits_[0] |= 0x00000040u;
  return device_os_codename_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_os_codename() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_os_codename)
  if (!_internal_has_device_os_codename()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  auto* p = device_os_codename_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_codename_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_codename_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_os_codename(std::string* device_os_codename) {
  if (device_os_codename != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  device_os_codename_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_os_codename,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_os_codename_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_os_codename_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_os_codename)
}

// optional string device_software_version = 17;
inline bool GcmDeviceInfo::_internal_has_device_software_version() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_software_version() const {
  return _internal_has_device_software_version();
}
inline void GcmDeviceInfo::clear_device_software_version() {
  device_software_version_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000080u;
}
inline const std::string& GcmDeviceInfo::device_software_version() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_software_version)
  return _internal_device_software_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_software_version(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000080u;
 device_software_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_software_version)
}
inline std::string* GcmDeviceInfo::mutable_device_software_version() {
  std::string* _s = _internal_mutable_device_software_version();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_software_version)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_software_version() const {
  return device_software_version_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_software_version(const std::string& value) {
  _has_bits_[0] |= 0x00000080u;
  device_software_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_software_version() {
  _has_bits_[0] |= 0x00000080u;
  return device_software_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_software_version() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_software_version)
  if (!_internal_has_device_software_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000080u;
  auto* p = device_software_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_software_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_software_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_software_version(std::string* device_software_version) {
  if (device_software_version != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  device_software_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_software_version,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_software_version_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_software_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_software_version)
}

// optional int64 device_software_version_code = 18;
inline bool GcmDeviceInfo::_internal_has_device_software_version_code() const {
  bool value = (_has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_software_version_code() const {
  return _internal_has_device_software_version_code();
}
inline void GcmDeviceInfo::clear_device_software_version_code() {
  device_software_version_code_ = int64_t{0};
  _has_bits_[0] &= ~0x00100000u;
}
inline int64_t GcmDeviceInfo::_internal_device_software_version_code() const {
  return device_software_version_code_;
}
inline int64_t GcmDeviceInfo::device_software_version_code() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_software_version_code)
  return _internal_device_software_version_code();
}
inline void GcmDeviceInfo::_internal_set_device_software_version_code(int64_t value) {
  _has_bits_[0] |= 0x00100000u;
  device_software_version_code_ = value;
}
inline void GcmDeviceInfo::set_device_software_version_code(int64_t value) {
  _internal_set_device_software_version_code(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_software_version_code)
}

// optional string device_software_package = 19;
inline bool GcmDeviceInfo::_internal_has_device_software_package() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_software_package() const {
  return _internal_has_device_software_package();
}
inline void GcmDeviceInfo::clear_device_software_package() {
  device_software_package_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000100u;
}
inline const std::string& GcmDeviceInfo::device_software_package() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_software_package)
  return _internal_device_software_package();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_software_package(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000100u;
 device_software_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_software_package)
}
inline std::string* GcmDeviceInfo::mutable_device_software_package() {
  std::string* _s = _internal_mutable_device_software_package();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_software_package)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_software_package() const {
  return device_software_package_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_software_package(const std::string& value) {
  _has_bits_[0] |= 0x00000100u;
  device_software_package_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_software_package() {
  _has_bits_[0] |= 0x00000100u;
  return device_software_package_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_software_package() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_software_package)
  if (!_internal_has_device_software_package()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000100u;
  auto* p = device_software_package_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_software_package_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_software_package_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_software_package(std::string* device_software_package) {
  if (device_software_package != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  device_software_package_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_software_package,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_software_package_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_software_package_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_software_package)
}

// optional int32 device_display_diagonal_mils = 22;
inline bool GcmDeviceInfo::_internal_has_device_display_diagonal_mils() const {
  bool value = (_has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_display_diagonal_mils() const {
  return _internal_has_device_display_diagonal_mils();
}
inline void GcmDeviceInfo::clear_device_display_diagonal_mils() {
  device_display_diagonal_mils_ = 0;
  _has_bits_[0] &= ~0x00200000u;
}
inline int32_t GcmDeviceInfo::_internal_device_display_diagonal_mils() const {
  return device_display_diagonal_mils_;
}
inline int32_t GcmDeviceInfo::device_display_diagonal_mils() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_display_diagonal_mils)
  return _internal_device_display_diagonal_mils();
}
inline void GcmDeviceInfo::_internal_set_device_display_diagonal_mils(int32_t value) {
  _has_bits_[0] |= 0x00200000u;
  device_display_diagonal_mils_ = value;
}
inline void GcmDeviceInfo::set_device_display_diagonal_mils(int32_t value) {
  _internal_set_device_display_diagonal_mils(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_display_diagonal_mils)
}

// optional int32 device_authzen_version = 24;
inline bool GcmDeviceInfo::_internal_has_device_authzen_version() const {
  bool value = (_has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_authzen_version() const {
  return _internal_has_device_authzen_version();
}
inline void GcmDeviceInfo::clear_device_authzen_version() {
  device_authzen_version_ = 0;
  _has_bits_[0] &= ~0x00400000u;
}
inline int32_t GcmDeviceInfo::_internal_device_authzen_version() const {
  return device_authzen_version_;
}
inline int32_t GcmDeviceInfo::device_authzen_version() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_authzen_version)
  return _internal_device_authzen_version();
}
inline void GcmDeviceInfo::_internal_set_device_authzen_version(int32_t value) {
  _has_bits_[0] |= 0x00400000u;
  device_authzen_version_ = value;
}
inline void GcmDeviceInfo::set_device_authzen_version(int32_t value) {
  _internal_set_device_authzen_version(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_authzen_version)
}

// optional bytes long_device_id = 29;
inline bool GcmDeviceInfo::_internal_has_long_device_id() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_long_device_id() const {
  return _internal_has_long_device_id();
}
inline void GcmDeviceInfo::clear_long_device_id() {
  long_device_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000200u;
}
inline const std::string& GcmDeviceInfo::long_device_id() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.long_device_id)
  return _internal_long_device_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_long_device_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000200u;
 long_device_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.long_device_id)
}
inline std::string* GcmDeviceInfo::mutable_long_device_id() {
  std::string* _s = _internal_mutable_long_device_id();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.long_device_id)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_long_device_id() const {
  return long_device_id_.Get();
}
inline void GcmDeviceInfo::_internal_set_long_device_id(const std::string& value) {
  _has_bits_[0] |= 0x00000200u;
  long_device_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_long_device_id() {
  _has_bits_[0] |= 0x00000200u;
  return long_device_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_long_device_id() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.long_device_id)
  if (!_internal_has_long_device_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000200u;
  auto* p = long_device_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (long_device_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    long_device_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_long_device_id(std::string* long_device_id) {
  if (long_device_id != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  long_device_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), long_device_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (long_device_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    long_device_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.long_device_id)
}

// optional string device_manufacturer = 31;
inline bool GcmDeviceInfo::_internal_has_device_manufacturer() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_manufacturer() const {
  return _internal_has_device_manufacturer();
}
inline void GcmDeviceInfo::clear_device_manufacturer() {
  device_manufacturer_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000400u;
}
inline const std::string& GcmDeviceInfo::device_manufacturer() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_manufacturer)
  return _internal_device_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_device_manufacturer(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000400u;
 device_manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_manufacturer)
}
inline std::string* GcmDeviceInfo::mutable_device_manufacturer() {
  std::string* _s = _internal_mutable_device_manufacturer();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.device_manufacturer)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_device_manufacturer() const {
  return device_manufacturer_.Get();
}
inline void GcmDeviceInfo::_internal_set_device_manufacturer(const std::string& value) {
  _has_bits_[0] |= 0x00000400u;
  device_manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_device_manufacturer() {
  _has_bits_[0] |= 0x00000400u;
  return device_manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_device_manufacturer() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.device_manufacturer)
  if (!_internal_has_device_manufacturer()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000400u;
  auto* p = device_manufacturer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_manufacturer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_manufacturer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_device_manufacturer(std::string* device_manufacturer) {
  if (device_manufacturer != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  device_manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_manufacturer,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (device_manufacturer_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    device_manufacturer_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.device_manufacturer)
}

// optional .securegcm.DeviceType device_type = 32 [default = ANDROID];
inline bool GcmDeviceInfo::_internal_has_device_type() const {
  bool value = (_has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_device_type() const {
  return _internal_has_device_type();
}
inline void GcmDeviceInfo::clear_device_type() {
  device_type_ = 1;
  _has_bits_[1] &= ~0x00000004u;
}
inline ::securegcm::DeviceType GcmDeviceInfo::_internal_device_type() const {
  return static_cast< ::securegcm::DeviceType >(device_type_);
}
inline ::securegcm::DeviceType GcmDeviceInfo::device_type() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.device_type)
  return _internal_device_type();
}
inline void GcmDeviceInfo::_internal_set_device_type(::securegcm::DeviceType value) {
  assert(::securegcm::DeviceType_IsValid(value));
  _has_bits_[1] |= 0x00000004u;
  device_type_ = value;
}
inline void GcmDeviceInfo::set_device_type(::securegcm::DeviceType value) {
  _internal_set_device_type(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.device_type)
}

// optional bool using_secure_screenlock = 400 [default = false];
inline bool GcmDeviceInfo::_internal_has_using_secure_screenlock() const {
  bool value = (_has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_using_secure_screenlock() const {
  return _internal_has_using_secure_screenlock();
}
inline void GcmDeviceInfo::clear_using_secure_screenlock() {
  using_secure_screenlock_ = false;
  _has_bits_[0] &= ~0x04000000u;
}
inline bool GcmDeviceInfo::_internal_using_secure_screenlock() const {
  return using_secure_screenlock_;
}
inline bool GcmDeviceInfo::using_secure_screenlock() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.using_secure_screenlock)
  return _internal_using_secure_screenlock();
}
inline void GcmDeviceInfo::_internal_set_using_secure_screenlock(bool value) {
  _has_bits_[0] |= 0x04000000u;
  using_secure_screenlock_ = value;
}
inline void GcmDeviceInfo::set_using_secure_screenlock(bool value) {
  _internal_set_using_secure_screenlock(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.using_secure_screenlock)
}

// optional bool auto_unlock_screenlock_supported = 401 [default = false];
inline bool GcmDeviceInfo::_internal_has_auto_unlock_screenlock_supported() const {
  bool value = (_has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_auto_unlock_screenlock_supported() const {
  return _internal_has_auto_unlock_screenlock_supported();
}
inline void GcmDeviceInfo::clear_auto_unlock_screenlock_supported() {
  auto_unlock_screenlock_supported_ = false;
  _has_bits_[0] &= ~0x08000000u;
}
inline bool GcmDeviceInfo::_internal_auto_unlock_screenlock_supported() const {
  return auto_unlock_screenlock_supported_;
}
inline bool GcmDeviceInfo::auto_unlock_screenlock_supported() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.auto_unlock_screenlock_supported)
  return _internal_auto_unlock_screenlock_supported();
}
inline void GcmDeviceInfo::_internal_set_auto_unlock_screenlock_supported(bool value) {
  _has_bits_[0] |= 0x08000000u;
  auto_unlock_screenlock_supported_ = value;
}
inline void GcmDeviceInfo::set_auto_unlock_screenlock_supported(bool value) {
  _internal_set_auto_unlock_screenlock_supported(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.auto_unlock_screenlock_supported)
}

// optional bool auto_unlock_screenlock_enabled = 402 [default = false];
inline bool GcmDeviceInfo::_internal_has_auto_unlock_screenlock_enabled() const {
  bool value = (_has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_auto_unlock_screenlock_enabled() const {
  return _internal_has_auto_unlock_screenlock_enabled();
}
inline void GcmDeviceInfo::clear_auto_unlock_screenlock_enabled() {
  auto_unlock_screenlock_enabled_ = false;
  _has_bits_[0] &= ~0x10000000u;
}
inline bool GcmDeviceInfo::_internal_auto_unlock_screenlock_enabled() const {
  return auto_unlock_screenlock_enabled_;
}
inline bool GcmDeviceInfo::auto_unlock_screenlock_enabled() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.auto_unlock_screenlock_enabled)
  return _internal_auto_unlock_screenlock_enabled();
}
inline void GcmDeviceInfo::_internal_set_auto_unlock_screenlock_enabled(bool value) {
  _has_bits_[0] |= 0x10000000u;
  auto_unlock_screenlock_enabled_ = value;
}
inline void GcmDeviceInfo::set_auto_unlock_screenlock_enabled(bool value) {
  _internal_set_auto_unlock_screenlock_enabled(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.auto_unlock_screenlock_enabled)
}

// optional bool bluetooth_radio_supported = 403 [default = false];
inline bool GcmDeviceInfo::_internal_has_bluetooth_radio_supported() const {
  bool value = (_has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_bluetooth_radio_supported() const {
  return _internal_has_bluetooth_radio_supported();
}
inline void GcmDeviceInfo::clear_bluetooth_radio_supported() {
  bluetooth_radio_supported_ = false;
  _has_bits_[0] &= ~0x20000000u;
}
inline bool GcmDeviceInfo::_internal_bluetooth_radio_supported() const {
  return bluetooth_radio_supported_;
}
inline bool GcmDeviceInfo::bluetooth_radio_supported() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.bluetooth_radio_supported)
  return _internal_bluetooth_radio_supported();
}
inline void GcmDeviceInfo::_internal_set_bluetooth_radio_supported(bool value) {
  _has_bits_[0] |= 0x20000000u;
  bluetooth_radio_supported_ = value;
}
inline void GcmDeviceInfo::set_bluetooth_radio_supported(bool value) {
  _internal_set_bluetooth_radio_supported(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.bluetooth_radio_supported)
}

// optional bool bluetooth_radio_enabled = 404 [default = false];
inline bool GcmDeviceInfo::_internal_has_bluetooth_radio_enabled() const {
  bool value = (_has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_bluetooth_radio_enabled() const {
  return _internal_has_bluetooth_radio_enabled();
}
inline void GcmDeviceInfo::clear_bluetooth_radio_enabled() {
  bluetooth_radio_enabled_ = false;
  _has_bits_[0] &= ~0x40000000u;
}
inline bool GcmDeviceInfo::_internal_bluetooth_radio_enabled() const {
  return bluetooth_radio_enabled_;
}
inline bool GcmDeviceInfo::bluetooth_radio_enabled() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.bluetooth_radio_enabled)
  return _internal_bluetooth_radio_enabled();
}
inline void GcmDeviceInfo::_internal_set_bluetooth_radio_enabled(bool value) {
  _has_bits_[0] |= 0x40000000u;
  bluetooth_radio_enabled_ = value;
}
inline void GcmDeviceInfo::set_bluetooth_radio_enabled(bool value) {
  _internal_set_bluetooth_radio_enabled(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.bluetooth_radio_enabled)
}

// optional bool mobile_data_supported = 405 [default = false];
inline bool GcmDeviceInfo::_internal_has_mobile_data_supported() const {
  bool value = (_has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_mobile_data_supported() const {
  return _internal_has_mobile_data_supported();
}
inline void GcmDeviceInfo::clear_mobile_data_supported() {
  mobile_data_supported_ = false;
  _has_bits_[0] &= ~0x80000000u;
}
inline bool GcmDeviceInfo::_internal_mobile_data_supported() const {
  return mobile_data_supported_;
}
inline bool GcmDeviceInfo::mobile_data_supported() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.mobile_data_supported)
  return _internal_mobile_data_supported();
}
inline void GcmDeviceInfo::_internal_set_mobile_data_supported(bool value) {
  _has_bits_[0] |= 0x80000000u;
  mobile_data_supported_ = value;
}
inline void GcmDeviceInfo::set_mobile_data_supported(bool value) {
  _internal_set_mobile_data_supported(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.mobile_data_supported)
}

// optional bool tethering_supported = 406 [default = false];
inline bool GcmDeviceInfo::_internal_has_tethering_supported() const {
  bool value = (_has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_tethering_supported() const {
  return _internal_has_tethering_supported();
}
inline void GcmDeviceInfo::clear_tethering_supported() {
  tethering_supported_ = false;
  _has_bits_[1] &= ~0x00000001u;
}
inline bool GcmDeviceInfo::_internal_tethering_supported() const {
  return tethering_supported_;
}
inline bool GcmDeviceInfo::tethering_supported() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.tethering_supported)
  return _internal_tethering_supported();
}
inline void GcmDeviceInfo::_internal_set_tethering_supported(bool value) {
  _has_bits_[1] |= 0x00000001u;
  tethering_supported_ = value;
}
inline void GcmDeviceInfo::set_tethering_supported(bool value) {
  _internal_set_tethering_supported(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.tethering_supported)
}

// optional bool ble_radio_supported = 407 [default = false];
inline bool GcmDeviceInfo::_internal_has_ble_radio_supported() const {
  bool value = (_has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_ble_radio_supported() const {
  return _internal_has_ble_radio_supported();
}
inline void GcmDeviceInfo::clear_ble_radio_supported() {
  ble_radio_supported_ = false;
  _has_bits_[1] &= ~0x00000002u;
}
inline bool GcmDeviceInfo::_internal_ble_radio_supported() const {
  return ble_radio_supported_;
}
inline bool GcmDeviceInfo::ble_radio_supported() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.ble_radio_supported)
  return _internal_ble_radio_supported();
}
inline void GcmDeviceInfo::_internal_set_ble_radio_supported(bool value) {
  _has_bits_[1] |= 0x00000002u;
  ble_radio_supported_ = value;
}
inline void GcmDeviceInfo::set_ble_radio_supported(bool value) {
  _internal_set_ble_radio_supported(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.ble_radio_supported)
}

// optional bool pixel_experience = 408 [default = false];
inline bool GcmDeviceInfo::_internal_has_pixel_experience() const {
  bool value = (_has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_pixel_experience() const {
  return _internal_has_pixel_experience();
}
inline void GcmDeviceInfo::clear_pixel_experience() {
  pixel_experience_ = false;
  _has_bits_[0] &= ~0x00800000u;
}
inline bool GcmDeviceInfo::_internal_pixel_experience() const {
  return pixel_experience_;
}
inline bool GcmDeviceInfo::pixel_experience() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.pixel_experience)
  return _internal_pixel_experience();
}
inline void GcmDeviceInfo::_internal_set_pixel_experience(bool value) {
  _has_bits_[0] |= 0x00800000u;
  pixel_experience_ = value;
}
inline void GcmDeviceInfo::set_pixel_experience(bool value) {
  _internal_set_pixel_experience(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.pixel_experience)
}

// optional bool arc_plus_plus = 409 [default = false];
inline bool GcmDeviceInfo::_internal_has_arc_plus_plus() const {
  bool value = (_has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_arc_plus_plus() const {
  return _internal_has_arc_plus_plus();
}
inline void GcmDeviceInfo::clear_arc_plus_plus() {
  arc_plus_plus_ = false;
  _has_bits_[0] &= ~0x01000000u;
}
inline bool GcmDeviceInfo::_internal_arc_plus_plus() const {
  return arc_plus_plus_;
}
inline bool GcmDeviceInfo::arc_plus_plus() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.arc_plus_plus)
  return _internal_arc_plus_plus();
}
inline void GcmDeviceInfo::_internal_set_arc_plus_plus(bool value) {
  _has_bits_[0] |= 0x01000000u;
  arc_plus_plus_ = value;
}
inline void GcmDeviceInfo::set_arc_plus_plus(bool value) {
  _internal_set_arc_plus_plus(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.arc_plus_plus)
}

// optional bool is_screenlock_state_flaky = 410 [default = false];
inline bool GcmDeviceInfo::_internal_has_is_screenlock_state_flaky() const {
  bool value = (_has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_is_screenlock_state_flaky() const {
  return _internal_has_is_screenlock_state_flaky();
}
inline void GcmDeviceInfo::clear_is_screenlock_state_flaky() {
  is_screenlock_state_flaky_ = false;
  _has_bits_[0] &= ~0x02000000u;
}
inline bool GcmDeviceInfo::_internal_is_screenlock_state_flaky() const {
  return is_screenlock_state_flaky_;
}
inline bool GcmDeviceInfo::is_screenlock_state_flaky() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.is_screenlock_state_flaky)
  return _internal_is_screenlock_state_flaky();
}
inline void GcmDeviceInfo::_internal_set_is_screenlock_state_flaky(bool value) {
  _has_bits_[0] |= 0x02000000u;
  is_screenlock_state_flaky_ = value;
}
inline void GcmDeviceInfo::set_is_screenlock_state_flaky(bool value) {
  _internal_set_is_screenlock_state_flaky(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.is_screenlock_state_flaky)
}

// repeated .securegcm.SoftwareFeature supported_software_features = 411;
inline int GcmDeviceInfo::_internal_supported_software_features_size() const {
  return supported_software_features_.size();
}
inline int GcmDeviceInfo::supported_software_features_size() const {
  return _internal_supported_software_features_size();
}
inline void GcmDeviceInfo::clear_supported_software_features() {
  supported_software_features_.Clear();
}
inline ::securegcm::SoftwareFeature GcmDeviceInfo::_internal_supported_software_features(int index) const {
  return static_cast< ::securegcm::SoftwareFeature >(supported_software_features_.Get(index));
}
inline ::securegcm::SoftwareFeature GcmDeviceInfo::supported_software_features(int index) const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.supported_software_features)
  return _internal_supported_software_features(index);
}
inline void GcmDeviceInfo::set_supported_software_features(int index, ::securegcm::SoftwareFeature value) {
  assert(::securegcm::SoftwareFeature_IsValid(value));
  supported_software_features_.Set(index, value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.supported_software_features)
}
inline void GcmDeviceInfo::_internal_add_supported_software_features(::securegcm::SoftwareFeature value) {
  assert(::securegcm::SoftwareFeature_IsValid(value));
  supported_software_features_.Add(value);
}
inline void GcmDeviceInfo::add_supported_software_features(::securegcm::SoftwareFeature value) {
  _internal_add_supported_software_features(value);
  // @@protoc_insertion_point(field_add:securegcm.GcmDeviceInfo.supported_software_features)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
GcmDeviceInfo::supported_software_features() const {
  // @@protoc_insertion_point(field_list:securegcm.GcmDeviceInfo.supported_software_features)
  return supported_software_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
GcmDeviceInfo::_internal_mutable_supported_software_features() {
  return &supported_software_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
GcmDeviceInfo::mutable_supported_software_features() {
  // @@protoc_insertion_point(field_mutable_list:securegcm.GcmDeviceInfo.supported_software_features)
  return _internal_mutable_supported_software_features();
}

// repeated .securegcm.SoftwareFeature enabled_software_features = 412;
inline int GcmDeviceInfo::_internal_enabled_software_features_size() const {
  return enabled_software_features_.size();
}
inline int GcmDeviceInfo::enabled_software_features_size() const {
  return _internal_enabled_software_features_size();
}
inline void GcmDeviceInfo::clear_enabled_software_features() {
  enabled_software_features_.Clear();
}
inline ::securegcm::SoftwareFeature GcmDeviceInfo::_internal_enabled_software_features(int index) const {
  return static_cast< ::securegcm::SoftwareFeature >(enabled_software_features_.Get(index));
}
inline ::securegcm::SoftwareFeature GcmDeviceInfo::enabled_software_features(int index) const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.enabled_software_features)
  return _internal_enabled_software_features(index);
}
inline void GcmDeviceInfo::set_enabled_software_features(int index, ::securegcm::SoftwareFeature value) {
  assert(::securegcm::SoftwareFeature_IsValid(value));
  enabled_software_features_.Set(index, value);
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.enabled_software_features)
}
inline void GcmDeviceInfo::_internal_add_enabled_software_features(::securegcm::SoftwareFeature value) {
  assert(::securegcm::SoftwareFeature_IsValid(value));
  enabled_software_features_.Add(value);
}
inline void GcmDeviceInfo::add_enabled_software_features(::securegcm::SoftwareFeature value) {
  _internal_add_enabled_software_features(value);
  // @@protoc_insertion_point(field_add:securegcm.GcmDeviceInfo.enabled_software_features)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
GcmDeviceInfo::enabled_software_features() const {
  // @@protoc_insertion_point(field_list:securegcm.GcmDeviceInfo.enabled_software_features)
  return enabled_software_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
GcmDeviceInfo::_internal_mutable_enabled_software_features() {
  return &enabled_software_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
GcmDeviceInfo::mutable_enabled_software_features() {
  // @@protoc_insertion_point(field_mutable_list:securegcm.GcmDeviceInfo.enabled_software_features)
  return _internal_mutable_enabled_software_features();
}

// optional bytes enrollment_session_id = 1000;
inline bool GcmDeviceInfo::_internal_has_enrollment_session_id() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_enrollment_session_id() const {
  return _internal_has_enrollment_session_id();
}
inline void GcmDeviceInfo::clear_enrollment_session_id() {
  enrollment_session_id_.ClearToEmpty();
  _has_bits_[0] &= ~0x00008000u;
}
inline const std::string& GcmDeviceInfo::enrollment_session_id() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.enrollment_session_id)
  return _internal_enrollment_session_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_enrollment_session_id(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00008000u;
 enrollment_session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.enrollment_session_id)
}
inline std::string* GcmDeviceInfo::mutable_enrollment_session_id() {
  std::string* _s = _internal_mutable_enrollment_session_id();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.enrollment_session_id)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_enrollment_session_id() const {
  return enrollment_session_id_.Get();
}
inline void GcmDeviceInfo::_internal_set_enrollment_session_id(const std::string& value) {
  _has_bits_[0] |= 0x00008000u;
  enrollment_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_enrollment_session_id() {
  _has_bits_[0] |= 0x00008000u;
  return enrollment_session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_enrollment_session_id() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.enrollment_session_id)
  if (!_internal_has_enrollment_session_id()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00008000u;
  auto* p = enrollment_session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (enrollment_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    enrollment_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_enrollment_session_id(std::string* enrollment_session_id) {
  if (enrollment_session_id != nullptr) {
    _has_bits_[0] |= 0x00008000u;
  } else {
    _has_bits_[0] &= ~0x00008000u;
  }
  enrollment_session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), enrollment_session_id,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (enrollment_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    enrollment_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.enrollment_session_id)
}

// optional string oauth_token = 1001;
inline bool GcmDeviceInfo::_internal_has_oauth_token() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool GcmDeviceInfo::has_oauth_token() const {
  return _internal_has_oauth_token();
}
inline void GcmDeviceInfo::clear_oauth_token() {
  oauth_token_.ClearToEmpty();
  _has_bits_[0] &= ~0x00010000u;
}
inline const std::string& GcmDeviceInfo::oauth_token() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmDeviceInfo.oauth_token)
  return _internal_oauth_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GcmDeviceInfo::set_oauth_token(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00010000u;
 oauth_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.GcmDeviceInfo.oauth_token)
}
inline std::string* GcmDeviceInfo::mutable_oauth_token() {
  std::string* _s = _internal_mutable_oauth_token();
  // @@protoc_insertion_point(field_mutable:securegcm.GcmDeviceInfo.oauth_token)
  return _s;
}
inline const std::string& GcmDeviceInfo::_internal_oauth_token() const {
  return oauth_token_.Get();
}
inline void GcmDeviceInfo::_internal_set_oauth_token(const std::string& value) {
  _has_bits_[0] |= 0x00010000u;
  oauth_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::_internal_mutable_oauth_token() {
  _has_bits_[0] |= 0x00010000u;
  return oauth_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* GcmDeviceInfo::release_oauth_token() {
  // @@protoc_insertion_point(field_release:securegcm.GcmDeviceInfo.oauth_token)
  if (!_internal_has_oauth_token()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00010000u;
  auto* p = oauth_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (oauth_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    oauth_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GcmDeviceInfo::set_allocated_oauth_token(std::string* oauth_token) {
  if (oauth_token != nullptr) {
    _has_bits_[0] |= 0x00010000u;
  } else {
    _has_bits_[0] &= ~0x00010000u;
  }
  oauth_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oauth_token,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (oauth_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    oauth_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.GcmDeviceInfo.oauth_token)
}

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

// GcmMetadata

// required .securegcm.Type type = 1;
inline bool GcmMetadata::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GcmMetadata::has_type() const {
  return _internal_has_type();
}
inline void GcmMetadata::clear_type() {
  type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::securegcm::Type GcmMetadata::_internal_type() const {
  return static_cast< ::securegcm::Type >(type_);
}
inline ::securegcm::Type GcmMetadata::type() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmMetadata.type)
  return _internal_type();
}
inline void GcmMetadata::_internal_set_type(::securegcm::Type value) {
  assert(::securegcm::Type_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  type_ = value;
}
inline void GcmMetadata::set_type(::securegcm::Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmMetadata.type)
}

// optional int32 version = 2 [default = 0];
inline bool GcmMetadata::_internal_has_version() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GcmMetadata::has_version() const {
  return _internal_has_version();
}
inline void GcmMetadata::clear_version() {
  version_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline int32_t GcmMetadata::_internal_version() const {
  return version_;
}
inline int32_t GcmMetadata::version() const {
  // @@protoc_insertion_point(field_get:securegcm.GcmMetadata.version)
  return _internal_version();
}
inline void GcmMetadata::_internal_set_version(int32_t value) {
  _has_bits_[0] |= 0x00000002u;
  version_ = value;
}
inline void GcmMetadata::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:securegcm.GcmMetadata.version)
}

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

// Tickle

// optional fixed64 expiry_time = 1;
inline bool Tickle::_internal_has_expiry_time() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Tickle::has_expiry_time() const {
  return _internal_has_expiry_time();
}
inline void Tickle::clear_expiry_time() {
  expiry_time_ = uint64_t{0u};
  _has_bits_[0] &= ~0x00000001u;
}
inline uint64_t Tickle::_internal_expiry_time() const {
  return expiry_time_;
}
inline uint64_t Tickle::expiry_time() const {
  // @@protoc_insertion_point(field_get:securegcm.Tickle.expiry_time)
  return _internal_expiry_time();
}
inline void Tickle::_internal_set_expiry_time(uint64_t value) {
  _has_bits_[0] |= 0x00000001u;
  expiry_time_ = value;
}
inline void Tickle::set_expiry_time(uint64_t value) {
  _internal_set_expiry_time(value);
  // @@protoc_insertion_point(field_set:securegcm.Tickle.expiry_time)
}

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

// LoginNotificationInfo

// optional fixed64 creation_time = 2;
inline bool LoginNotificationInfo::_internal_has_creation_time() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool LoginNotificationInfo::has_creation_time() const {
  return _internal_has_creation_time();
}
inline void LoginNotificationInfo::clear_creation_time() {
  creation_time_ = uint64_t{0u};
  _has_bits_[0] &= ~0x00000010u;
}
inline uint64_t LoginNotificationInfo::_internal_creation_time() const {
  return creation_time_;
}
inline uint64_t LoginNotificationInfo::creation_time() const {
  // @@protoc_insertion_point(field_get:securegcm.LoginNotificationInfo.creation_time)
  return _internal_creation_time();
}
inline void LoginNotificationInfo::_internal_set_creation_time(uint64_t value) {
  _has_bits_[0] |= 0x00000010u;
  creation_time_ = value;
}
inline void LoginNotificationInfo::set_creation_time(uint64_t value) {
  _internal_set_creation_time(value);
  // @@protoc_insertion_point(field_set:securegcm.LoginNotificationInfo.creation_time)
}

// optional string email = 3;
inline bool LoginNotificationInfo::_internal_has_email() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LoginNotificationInfo::has_email() const {
  return _internal_has_email();
}
inline void LoginNotificationInfo::clear_email() {
  email_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LoginNotificationInfo::email() const {
  // @@protoc_insertion_point(field_get:securegcm.LoginNotificationInfo.email)
  return _internal_email();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginNotificationInfo::set_email(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 email_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.LoginNotificationInfo.email)
}
inline std::string* LoginNotificationInfo::mutable_email() {
  std::string* _s = _internal_mutable_email();
  // @@protoc_insertion_point(field_mutable:securegcm.LoginNotificationInfo.email)
  return _s;
}
inline const std::string& LoginNotificationInfo::_internal_email() const {
  return email_.Get();
}
inline void LoginNotificationInfo::_internal_set_email(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  email_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::_internal_mutable_email() {
  _has_bits_[0] |= 0x00000001u;
  return email_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::release_email() {
  // @@protoc_insertion_point(field_release:securegcm.LoginNotificationInfo.email)
  if (!_internal_has_email()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = email_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (email_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LoginNotificationInfo::set_allocated_email(std::string* email) {
  if (email != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  email_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), email,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (email_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.LoginNotificationInfo.email)
}

// optional string host = 4;
inline bool LoginNotificationInfo::_internal_has_host() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LoginNotificationInfo::has_host() const {
  return _internal_has_host();
}
inline void LoginNotificationInfo::clear_host() {
  host_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LoginNotificationInfo::host() const {
  // @@protoc_insertion_point(field_get:securegcm.LoginNotificationInfo.host)
  return _internal_host();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginNotificationInfo::set_host(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 host_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.LoginNotificationInfo.host)
}
inline std::string* LoginNotificationInfo::mutable_host() {
  std::string* _s = _internal_mutable_host();
  // @@protoc_insertion_point(field_mutable:securegcm.LoginNotificationInfo.host)
  return _s;
}
inline const std::string& LoginNotificationInfo::_internal_host() const {
  return host_.Get();
}
inline void LoginNotificationInfo::_internal_set_host(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  host_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::_internal_mutable_host() {
  _has_bits_[0] |= 0x00000002u;
  return host_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::release_host() {
  // @@protoc_insertion_point(field_release:securegcm.LoginNotificationInfo.host)
  if (!_internal_has_host()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = host_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (host_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    host_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LoginNotificationInfo::set_allocated_host(std::string* host) {
  if (host != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  host_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), host,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (host_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    host_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.LoginNotificationInfo.host)
}

// optional string source = 5;
inline bool LoginNotificationInfo::_internal_has_source() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LoginNotificationInfo::has_source() const {
  return _internal_has_source();
}
inline void LoginNotificationInfo::clear_source() {
  source_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& LoginNotificationInfo::source() const {
  // @@protoc_insertion_point(field_get:securegcm.LoginNotificationInfo.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginNotificationInfo::set_source(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.LoginNotificationInfo.source)
}
inline std::string* LoginNotificationInfo::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:securegcm.LoginNotificationInfo.source)
  return _s;
}
inline const std::string& LoginNotificationInfo::_internal_source() const {
  return source_.Get();
}
inline void LoginNotificationInfo::_internal_set_source(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  source_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::_internal_mutable_source() {
  _has_bits_[0] |= 0x00000004u;
  return source_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::release_source() {
  // @@protoc_insertion_point(field_release:securegcm.LoginNotificationInfo.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = source_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LoginNotificationInfo::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  source_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), source,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (source_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    source_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.LoginNotificationInfo.source)
}

// optional string event_type = 6;
inline bool LoginNotificationInfo::_internal_has_event_type() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool LoginNotificationInfo::has_event_type() const {
  return _internal_has_event_type();
}
inline void LoginNotificationInfo::clear_event_type() {
  event_type_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& LoginNotificationInfo::event_type() const {
  // @@protoc_insertion_point(field_get:securegcm.LoginNotificationInfo.event_type)
  return _internal_event_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginNotificationInfo::set_event_type(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000008u;
 event_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:securegcm.LoginNotificationInfo.event_type)
}
inline std::string* LoginNotificationInfo::mutable_event_type() {
  std::string* _s = _internal_mutable_event_type();
  // @@protoc_insertion_point(field_mutable:securegcm.LoginNotificationInfo.event_type)
  return _s;
}
inline const std::string& LoginNotificationInfo::_internal_event_type() const {
  return event_type_.Get();
}
inline void LoginNotificationInfo::_internal_set_event_type(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  event_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::_internal_mutable_event_type() {
  _has_bits_[0] |= 0x00000008u;
  return event_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* LoginNotificationInfo::release_event_type() {
  // @@protoc_insertion_point(field_release:securegcm.LoginNotificationInfo.event_type)
  if (!_internal_has_event_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  auto* p = event_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (event_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    event_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LoginNotificationInfo::set_allocated_event_type(std::string* event_type) {
  if (event_type != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  event_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), event_type,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (event_type_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    event_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:securegcm.LoginNotificationInfo.event_type)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace securegcm

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::securegcm::AppleDeviceDiagonalMils> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::DeviceType> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::SoftwareFeature> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::InvocationReason> : ::std::true_type {};
template <> struct is_proto_enum< ::securegcm::Type> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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