chromium/out/Default/gen/chrome/browser/enterprise/connectors/device_trust/attestation/common/proto/device_trust_attestation_ca.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: chrome/browser/enterprise/connectors/device_trust/attestation/common/proto/device_trust_attestation_ca.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_chrome_2fbrowser_2fenterprise_2fconnectors_2fdevice_5ftrust_2fattestation_2fcommon_2fproto_2fdevice_5ftrust_5fattestation_5fca_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_chrome_2fbrowser_2fenterprise_2fconnectors_2fdevice_5ftrust_2fattestation_2fcommon_2fproto_2fdevice_5ftrust_5fattestation_5fca_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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_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_chrome_2fbrowser_2fenterprise_2fconnectors_2fdevice_5ftrust_2fattestation_2fcommon_2fproto_2fdevice_5ftrust_5fattestation_5fca_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_chrome_2fbrowser_2fenterprise_2fconnectors_2fdevice_5ftrust_2fattestation_2fcommon_2fproto_2fdevice_5ftrust_5fattestation_5fca_2eproto { … };
namespace enterprise_connectors {
class Challenge;
struct ChallengeDefaultTypeInternal;
extern ChallengeDefaultTypeInternal _Challenge_default_instance_;
class ChallengeResponse;
struct ChallengeResponseDefaultTypeInternal;
extern ChallengeResponseDefaultTypeInternal _ChallengeResponse_default_instance_;
class DeviceTrustSignals;
struct DeviceTrustSignalsDefaultTypeInternal;
extern DeviceTrustSignalsDefaultTypeInternal _DeviceTrustSignals_default_instance_;
class EncryptedData;
struct EncryptedDataDefaultTypeInternal;
extern EncryptedDataDefaultTypeInternal _EncryptedData_default_instance_;
class KeyInfo;
struct KeyInfoDefaultTypeInternal;
extern KeyInfoDefaultTypeInternal _KeyInfo_default_instance_;
class SignedData;
struct SignedDataDefaultTypeInternal;
extern SignedDataDefaultTypeInternal _SignedData_default_instance_;
}  // namespace enterprise_connectors
PROTOBUF_NAMESPACE_OPEN
template<> ::enterprise_connectors::Challenge* Arena::CreateMaybeMessage<::enterprise_connectors::Challenge>(Arena*);
template<> ::enterprise_connectors::ChallengeResponse* Arena::CreateMaybeMessage<::enterprise_connectors::ChallengeResponse>(Arena*);
template<> ::enterprise_connectors::DeviceTrustSignals* Arena::CreateMaybeMessage<::enterprise_connectors::DeviceTrustSignals>(Arena*);
template<> ::enterprise_connectors::EncryptedData* Arena::CreateMaybeMessage<::enterprise_connectors::EncryptedData>(Arena*);
template<> ::enterprise_connectors::KeyInfo* Arena::CreateMaybeMessage<::enterprise_connectors::KeyInfo>(Arena*);
template<> ::enterprise_connectors::SignedData* Arena::CreateMaybeMessage<::enterprise_connectors::SignedData>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace enterprise_connectors {

enum VerifiedAccessFlow : int { … };
bool VerifiedAccessFlow_IsValid(int value);
constexpr VerifiedAccessFlow VerifiedAccessFlow_MIN = …;
constexpr VerifiedAccessFlow VerifiedAccessFlow_MAX = …;
constexpr int VerifiedAccessFlow_ARRAYSIZE = …;

const std::string& VerifiedAccessFlow_Name(VerifiedAccessFlow value);
template<typename T>
inline const std::string& VerifiedAccessFlow_Name(T enum_t_value) { … }
bool VerifiedAccessFlow_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VerifiedAccessFlow* value);
// ===================================================================

class EncryptedData final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.EncryptedData) */ { … };
// -------------------------------------------------------------------

class SignedData final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.SignedData) */ { … };
// -------------------------------------------------------------------

class Challenge final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.Challenge) */ { … };
// -------------------------------------------------------------------

class ChallengeResponse final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.ChallengeResponse) */ { … };
// -------------------------------------------------------------------

class KeyInfo final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.KeyInfo) */ { … };
// -------------------------------------------------------------------

class DeviceTrustSignals final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:enterprise_connectors.DeviceTrustSignals) */ { … };
// ===================================================================


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

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

// optional bytes wrapped_key = 2;
inline bool EncryptedData::_internal_has_wrapped_key() const { … }
inline bool EncryptedData::has_wrapped_key() const { … }
inline void EncryptedData::clear_wrapped_key() { … }
inline const std::string& EncryptedData::wrapped_key() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedData::set_wrapped_key(ArgT0&& arg0, ArgT... args) { … }
inline std::string* EncryptedData::mutable_wrapped_key() { … }
inline const std::string& EncryptedData::_internal_wrapped_key() const { … }
inline void EncryptedData::_internal_set_wrapped_key(const std::string& value) { … }
inline std::string* EncryptedData::_internal_mutable_wrapped_key() { … }
inline std::string* EncryptedData::release_wrapped_key() { … }
inline void EncryptedData::set_allocated_wrapped_key(std::string* wrapped_key) { … }

// optional bytes iv = 3;
inline bool EncryptedData::_internal_has_iv() const { … }
inline bool EncryptedData::has_iv() const { … }
inline void EncryptedData::clear_iv() { … }
inline const std::string& EncryptedData::iv() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedData::set_iv(ArgT0&& arg0, ArgT... args) { … }
inline std::string* EncryptedData::mutable_iv() { … }
inline const std::string& EncryptedData::_internal_iv() const { … }
inline void EncryptedData::_internal_set_iv(const std::string& value) { … }
inline std::string* EncryptedData::_internal_mutable_iv() { … }
inline std::string* EncryptedData::release_iv() { … }
inline void EncryptedData::set_allocated_iv(std::string* iv) { … }

// optional bytes mac = 4;
inline bool EncryptedData::_internal_has_mac() const { … }
inline bool EncryptedData::has_mac() const { … }
inline void EncryptedData::clear_mac() { … }
inline const std::string& EncryptedData::mac() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedData::set_mac(ArgT0&& arg0, ArgT... args) { … }
inline std::string* EncryptedData::mutable_mac() { … }
inline const std::string& EncryptedData::_internal_mac() const { … }
inline void EncryptedData::_internal_set_mac(const std::string& value) { … }
inline std::string* EncryptedData::_internal_mutable_mac() { … }
inline std::string* EncryptedData::release_mac() { … }
inline void EncryptedData::set_allocated_mac(std::string* mac) { … }

// optional bytes encrypted_data = 5;
inline bool EncryptedData::_internal_has_encrypted_data() const { … }
inline bool EncryptedData::has_encrypted_data() const { … }
inline void EncryptedData::clear_encrypted_data() { … }
inline const std::string& EncryptedData::encrypted_data() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedData::set_encrypted_data(ArgT0&& arg0, ArgT... args) { … }
inline std::string* EncryptedData::mutable_encrypted_data() { … }
inline const std::string& EncryptedData::_internal_encrypted_data() const { … }
inline void EncryptedData::_internal_set_encrypted_data(const std::string& value) { … }
inline std::string* EncryptedData::_internal_mutable_encrypted_data() { … }
inline std::string* EncryptedData::release_encrypted_data() { … }
inline void EncryptedData::set_allocated_encrypted_data(std::string* encrypted_data) { … }

// optional bytes wrapping_key_id = 6;
inline bool EncryptedData::_internal_has_wrapping_key_id() const { … }
inline bool EncryptedData::has_wrapping_key_id() const { … }
inline void EncryptedData::clear_wrapping_key_id() { … }
inline const std::string& EncryptedData::wrapping_key_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void EncryptedData::set_wrapping_key_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* EncryptedData::mutable_wrapping_key_id() { … }
inline const std::string& EncryptedData::_internal_wrapping_key_id() const { … }
inline void EncryptedData::_internal_set_wrapping_key_id(const std::string& value) { … }
inline std::string* EncryptedData::_internal_mutable_wrapping_key_id() { … }
inline std::string* EncryptedData::release_wrapping_key_id() { … }
inline void EncryptedData::set_allocated_wrapping_key_id(std::string* wrapping_key_id) { … }

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

// SignedData

// optional bytes data = 1;
inline bool SignedData::_internal_has_data() const { … }
inline bool SignedData::has_data() const { … }
inline void SignedData::clear_data() { … }
inline const std::string& SignedData::data() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedData::set_data(ArgT0&& arg0, ArgT... args) { … }
inline std::string* SignedData::mutable_data() { … }
inline const std::string& SignedData::_internal_data() const { … }
inline void SignedData::_internal_set_data(const std::string& value) { … }
inline std::string* SignedData::_internal_mutable_data() { … }
inline std::string* SignedData::release_data() { … }
inline void SignedData::set_allocated_data(std::string* data) { … }

// optional bytes signature = 2;
inline bool SignedData::_internal_has_signature() const { … }
inline bool SignedData::has_signature() const { … }
inline void SignedData::clear_signature() { … }
inline const std::string& SignedData::signature() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedData::set_signature(ArgT0&& arg0, ArgT... args) { … }
inline std::string* SignedData::mutable_signature() { … }
inline const std::string& SignedData::_internal_signature() const { … }
inline void SignedData::_internal_set_signature(const std::string& value) { … }
inline std::string* SignedData::_internal_mutable_signature() { … }
inline std::string* SignedData::release_signature() { … }
inline void SignedData::set_allocated_signature(std::string* signature) { … }

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

// Challenge

// optional string prefix = 1;
inline bool Challenge::_internal_has_prefix() const { … }
inline bool Challenge::has_prefix() const { … }
inline void Challenge::clear_prefix() { … }
inline const std::string& Challenge::prefix() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Challenge::set_prefix(ArgT0&& arg0, ArgT... args) { … }
inline std::string* Challenge::mutable_prefix() { … }
inline const std::string& Challenge::_internal_prefix() const { … }
inline void Challenge::_internal_set_prefix(const std::string& value) { … }
inline std::string* Challenge::_internal_mutable_prefix() { … }
inline std::string* Challenge::release_prefix() { … }
inline void Challenge::set_allocated_prefix(std::string* prefix) { … }

// optional bytes nonce = 2;
inline bool Challenge::_internal_has_nonce() const { … }
inline bool Challenge::has_nonce() const { … }
inline void Challenge::clear_nonce() { … }
inline const std::string& Challenge::nonce() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Challenge::set_nonce(ArgT0&& arg0, ArgT... args) { … }
inline std::string* Challenge::mutable_nonce() { … }
inline const std::string& Challenge::_internal_nonce() const { … }
inline void Challenge::_internal_set_nonce(const std::string& value) { … }
inline std::string* Challenge::_internal_mutable_nonce() { … }
inline std::string* Challenge::release_nonce() { … }
inline void Challenge::set_allocated_nonce(std::string* nonce) { … }

// optional int64 timestamp = 3;
inline bool Challenge::_internal_has_timestamp() const { … }
inline bool Challenge::has_timestamp() const { … }
inline void Challenge::clear_timestamp() { … }
inline int64_t Challenge::_internal_timestamp() const { … }
inline int64_t Challenge::timestamp() const { … }
inline void Challenge::_internal_set_timestamp(int64_t value) { … }
inline void Challenge::set_timestamp(int64_t value) { … }

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

// ChallengeResponse

// optional .enterprise_connectors.SignedData challenge = 1;
inline bool ChallengeResponse::_internal_has_challenge() const { … }
inline bool ChallengeResponse::has_challenge() const { … }
inline void ChallengeResponse::clear_challenge() { … }
inline const ::enterprise_connectors::SignedData& ChallengeResponse::_internal_challenge() const { … }
inline const ::enterprise_connectors::SignedData& ChallengeResponse::challenge() const { … }
inline void ChallengeResponse::unsafe_arena_set_allocated_challenge(
    ::enterprise_connectors::SignedData* challenge) { … }
inline ::enterprise_connectors::SignedData* ChallengeResponse::release_challenge() { … }
inline ::enterprise_connectors::SignedData* ChallengeResponse::unsafe_arena_release_challenge() { … }
inline ::enterprise_connectors::SignedData* ChallengeResponse::_internal_mutable_challenge() { … }
inline ::enterprise_connectors::SignedData* ChallengeResponse::mutable_challenge() { … }
inline void ChallengeResponse::set_allocated_challenge(::enterprise_connectors::SignedData* challenge) { … }

// optional bytes nonce = 2;
inline bool ChallengeResponse::_internal_has_nonce() const { … }
inline bool ChallengeResponse::has_nonce() const { … }
inline void ChallengeResponse::clear_nonce() { … }
inline const std::string& ChallengeResponse::nonce() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ChallengeResponse::set_nonce(ArgT0&& arg0, ArgT... args) { … }
inline std::string* ChallengeResponse::mutable_nonce() { … }
inline const std::string& ChallengeResponse::_internal_nonce() const { … }
inline void ChallengeResponse::_internal_set_nonce(const std::string& value) { … }
inline std::string* ChallengeResponse::_internal_mutable_nonce() { … }
inline std::string* ChallengeResponse::release_nonce() { … }
inline void ChallengeResponse::set_allocated_nonce(std::string* nonce) { … }

// optional .enterprise_connectors.EncryptedData encrypted_key_info = 3;
inline bool ChallengeResponse::_internal_has_encrypted_key_info() const { … }
inline bool ChallengeResponse::has_encrypted_key_info() const { … }
inline void ChallengeResponse::clear_encrypted_key_info() { … }
inline const ::enterprise_connectors::EncryptedData& ChallengeResponse::_internal_encrypted_key_info() const { … }
inline const ::enterprise_connectors::EncryptedData& ChallengeResponse::encrypted_key_info() const { … }
inline void ChallengeResponse::unsafe_arena_set_allocated_encrypted_key_info(
    ::enterprise_connectors::EncryptedData* encrypted_key_info) { … }
inline ::enterprise_connectors::EncryptedData* ChallengeResponse::release_encrypted_key_info() { … }
inline ::enterprise_connectors::EncryptedData* ChallengeResponse::unsafe_arena_release_encrypted_key_info() { … }
inline ::enterprise_connectors::EncryptedData* ChallengeResponse::_internal_mutable_encrypted_key_info() { … }
inline ::enterprise_connectors::EncryptedData* ChallengeResponse::mutable_encrypted_key_info() { … }
inline void ChallengeResponse::set_allocated_encrypted_key_info(::enterprise_connectors::EncryptedData* encrypted_key_info) { … }

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

// KeyInfo

// optional .enterprise_connectors.VerifiedAccessFlow flow_type = 1;
inline bool KeyInfo::_internal_has_flow_type() const { … }
inline bool KeyInfo::has_flow_type() const { … }
inline void KeyInfo::clear_flow_type() { … }
inline ::enterprise_connectors::VerifiedAccessFlow KeyInfo::_internal_flow_type() const { … }
inline ::enterprise_connectors::VerifiedAccessFlow KeyInfo::flow_type() const { … }
inline void KeyInfo::_internal_set_flow_type(::enterprise_connectors::VerifiedAccessFlow value) { … }
inline void KeyInfo::set_flow_type(::enterprise_connectors::VerifiedAccessFlow value) { … }

// optional string domain = 2;
inline bool KeyInfo::_internal_has_domain() const { … }
inline bool KeyInfo::has_domain() const { … }
inline void KeyInfo::clear_domain() { … }
inline const std::string& KeyInfo::domain() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_domain(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_domain() { … }
inline const std::string& KeyInfo::_internal_domain() const { … }
inline void KeyInfo::_internal_set_domain(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_domain() { … }
inline std::string* KeyInfo::release_domain() { … }
inline void KeyInfo::set_allocated_domain(std::string* domain) { … }

// optional bytes device_id = 3;
inline bool KeyInfo::_internal_has_device_id() const { … }
inline bool KeyInfo::has_device_id() const { … }
inline void KeyInfo::clear_device_id() { … }
inline const std::string& KeyInfo::device_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_device_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_device_id() { … }
inline const std::string& KeyInfo::_internal_device_id() const { … }
inline void KeyInfo::_internal_set_device_id(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_device_id() { … }
inline std::string* KeyInfo::release_device_id() { … }
inline void KeyInfo::set_allocated_device_id(std::string* device_id) { … }

// optional bytes certificate = 4;
inline bool KeyInfo::_internal_has_certificate() const { … }
inline bool KeyInfo::has_certificate() const { … }
inline void KeyInfo::clear_certificate() { … }
inline const std::string& KeyInfo::certificate() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_certificate(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_certificate() { … }
inline const std::string& KeyInfo::_internal_certificate() const { … }
inline void KeyInfo::_internal_set_certificate(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_certificate() { … }
inline std::string* KeyInfo::release_certificate() { … }
inline void KeyInfo::set_allocated_certificate(std::string* certificate) { … }

// optional bytes signed_public_key_and_challenge = 5;
inline bool KeyInfo::_internal_has_signed_public_key_and_challenge() const { … }
inline bool KeyInfo::has_signed_public_key_and_challenge() const { … }
inline void KeyInfo::clear_signed_public_key_and_challenge() { … }
inline const std::string& KeyInfo::signed_public_key_and_challenge() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_signed_public_key_and_challenge(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_signed_public_key_and_challenge() { … }
inline const std::string& KeyInfo::_internal_signed_public_key_and_challenge() const { … }
inline void KeyInfo::_internal_set_signed_public_key_and_challenge(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_signed_public_key_and_challenge() { … }
inline std::string* KeyInfo::release_signed_public_key_and_challenge() { … }
inline void KeyInfo::set_allocated_signed_public_key_and_challenge(std::string* signed_public_key_and_challenge) { … }

// optional string customer_id = 6;
inline bool KeyInfo::_internal_has_customer_id() const { … }
inline bool KeyInfo::has_customer_id() const { … }
inline void KeyInfo::clear_customer_id() { … }
inline const std::string& KeyInfo::customer_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_customer_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_customer_id() { … }
inline const std::string& KeyInfo::_internal_customer_id() const { … }
inline void KeyInfo::_internal_set_customer_id(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_customer_id() { … }
inline std::string* KeyInfo::release_customer_id() { … }
inline void KeyInfo::set_allocated_customer_id(std::string* customer_id) { … }

// optional bytes browser_instance_public_key = 7;
inline bool KeyInfo::_internal_has_browser_instance_public_key() const { … }
inline bool KeyInfo::has_browser_instance_public_key() const { … }
inline void KeyInfo::clear_browser_instance_public_key() { … }
inline const std::string& KeyInfo::browser_instance_public_key() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_browser_instance_public_key(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_browser_instance_public_key() { … }
inline const std::string& KeyInfo::_internal_browser_instance_public_key() const { … }
inline void KeyInfo::_internal_set_browser_instance_public_key(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_browser_instance_public_key() { … }
inline std::string* KeyInfo::release_browser_instance_public_key() { … }
inline void KeyInfo::set_allocated_browser_instance_public_key(std::string* browser_instance_public_key) { … }

// optional string signing_scheme = 8;
inline bool KeyInfo::_internal_has_signing_scheme() const { … }
inline bool KeyInfo::has_signing_scheme() const { … }
inline void KeyInfo::clear_signing_scheme() { … }
inline const std::string& KeyInfo::signing_scheme() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_signing_scheme(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_signing_scheme() { … }
inline const std::string& KeyInfo::_internal_signing_scheme() const { … }
inline void KeyInfo::_internal_set_signing_scheme(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_signing_scheme() { … }
inline std::string* KeyInfo::release_signing_scheme() { … }
inline void KeyInfo::set_allocated_signing_scheme(std::string* signing_scheme) { … }

// optional .enterprise_connectors.DeviceTrustSignals device_trust_signals = 9 [deprecated = true];
inline bool KeyInfo::_internal_has_device_trust_signals() const { … }
inline bool KeyInfo::has_device_trust_signals() const { … }
inline void KeyInfo::clear_device_trust_signals() { … }
inline const ::enterprise_connectors::DeviceTrustSignals& KeyInfo::_internal_device_trust_signals() const { … }
inline const ::enterprise_connectors::DeviceTrustSignals& KeyInfo::device_trust_signals() const { … }
inline void KeyInfo::unsafe_arena_set_allocated_device_trust_signals(
    ::enterprise_connectors::DeviceTrustSignals* device_trust_signals) { … }
inline ::enterprise_connectors::DeviceTrustSignals* KeyInfo::release_device_trust_signals() { … }
inline ::enterprise_connectors::DeviceTrustSignals* KeyInfo::unsafe_arena_release_device_trust_signals() { … }
inline ::enterprise_connectors::DeviceTrustSignals* KeyInfo::_internal_mutable_device_trust_signals() { … }
inline ::enterprise_connectors::DeviceTrustSignals* KeyInfo::mutable_device_trust_signals() { … }
inline void KeyInfo::set_allocated_device_trust_signals(::enterprise_connectors::DeviceTrustSignals* device_trust_signals) { … }

// optional string device_trust_signals_json = 10;
inline bool KeyInfo::_internal_has_device_trust_signals_json() const { … }
inline bool KeyInfo::has_device_trust_signals_json() const { … }
inline void KeyInfo::clear_device_trust_signals_json() { … }
inline const std::string& KeyInfo::device_trust_signals_json() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_device_trust_signals_json(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_device_trust_signals_json() { … }
inline const std::string& KeyInfo::_internal_device_trust_signals_json() const { … }
inline void KeyInfo::_internal_set_device_trust_signals_json(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_device_trust_signals_json() { … }
inline std::string* KeyInfo::release_device_trust_signals_json() { … }
inline void KeyInfo::set_allocated_device_trust_signals_json(std::string* device_trust_signals_json) { … }

// optional string dm_token = 11;
inline bool KeyInfo::_internal_has_dm_token() const { … }
inline bool KeyInfo::has_dm_token() const { … }
inline void KeyInfo::clear_dm_token() { … }
inline const std::string& KeyInfo::dm_token() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_dm_token(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_dm_token() { … }
inline const std::string& KeyInfo::_internal_dm_token() const { … }
inline void KeyInfo::_internal_set_dm_token(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_dm_token() { … }
inline std::string* KeyInfo::release_dm_token() { … }
inline void KeyInfo::set_allocated_dm_token(std::string* dm_token) { … }

// optional string user_customer_id = 12;
inline bool KeyInfo::_internal_has_user_customer_id() const { … }
inline bool KeyInfo::has_user_customer_id() const { … }
inline void KeyInfo::clear_user_customer_id() { … }
inline const std::string& KeyInfo::user_customer_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_user_customer_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_user_customer_id() { … }
inline const std::string& KeyInfo::_internal_user_customer_id() const { … }
inline void KeyInfo::_internal_set_user_customer_id(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_user_customer_id() { … }
inline std::string* KeyInfo::release_user_customer_id() { … }
inline void KeyInfo::set_allocated_user_customer_id(std::string* user_customer_id) { … }

// optional string obfuscated_gaia_id = 13;
inline bool KeyInfo::_internal_has_obfuscated_gaia_id() const { … }
inline bool KeyInfo::has_obfuscated_gaia_id() const { … }
inline void KeyInfo::clear_obfuscated_gaia_id() { … }
inline const std::string& KeyInfo::obfuscated_gaia_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_obfuscated_gaia_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_obfuscated_gaia_id() { … }
inline const std::string& KeyInfo::_internal_obfuscated_gaia_id() const { … }
inline void KeyInfo::_internal_set_obfuscated_gaia_id(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_obfuscated_gaia_id() { … }
inline std::string* KeyInfo::release_obfuscated_gaia_id() { … }
inline void KeyInfo::set_allocated_obfuscated_gaia_id(std::string* obfuscated_gaia_id) { … }

// optional string profile_id = 14;
inline bool KeyInfo::_internal_has_profile_id() const { … }
inline bool KeyInfo::has_profile_id() const { … }
inline void KeyInfo::clear_profile_id() { … }
inline const std::string& KeyInfo::profile_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyInfo::set_profile_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* KeyInfo::mutable_profile_id() { … }
inline const std::string& KeyInfo::_internal_profile_id() const { … }
inline void KeyInfo::_internal_set_profile_id(const std::string& value) { … }
inline std::string* KeyInfo::_internal_mutable_profile_id() { … }
inline std::string* KeyInfo::release_profile_id() { … }
inline void KeyInfo::set_allocated_profile_id(std::string* profile_id) { … }

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

// DeviceTrustSignals

// optional string device_id = 1;
inline bool DeviceTrustSignals::_internal_has_device_id() const { … }
inline bool DeviceTrustSignals::has_device_id() const { … }
inline void DeviceTrustSignals::clear_device_id() { … }
inline const std::string& DeviceTrustSignals::device_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_device_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_device_id() { … }
inline const std::string& DeviceTrustSignals::_internal_device_id() const { … }
inline void DeviceTrustSignals::_internal_set_device_id(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_device_id() { … }
inline std::string* DeviceTrustSignals::release_device_id() { … }
inline void DeviceTrustSignals::set_allocated_device_id(std::string* device_id) { … }

// optional string obfuscated_customer_id = 2;
inline bool DeviceTrustSignals::_internal_has_obfuscated_customer_id() const { … }
inline bool DeviceTrustSignals::has_obfuscated_customer_id() const { … }
inline void DeviceTrustSignals::clear_obfuscated_customer_id() { … }
inline const std::string& DeviceTrustSignals::obfuscated_customer_id() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_obfuscated_customer_id(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_obfuscated_customer_id() { … }
inline const std::string& DeviceTrustSignals::_internal_obfuscated_customer_id() const { … }
inline void DeviceTrustSignals::_internal_set_obfuscated_customer_id(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_obfuscated_customer_id() { … }
inline std::string* DeviceTrustSignals::release_obfuscated_customer_id() { … }
inline void DeviceTrustSignals::set_allocated_obfuscated_customer_id(std::string* obfuscated_customer_id) { … }

// optional string serial_number = 3;
inline bool DeviceTrustSignals::_internal_has_serial_number() const { … }
inline bool DeviceTrustSignals::has_serial_number() const { … }
inline void DeviceTrustSignals::clear_serial_number() { … }
inline const std::string& DeviceTrustSignals::serial_number() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_serial_number(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_serial_number() { … }
inline const std::string& DeviceTrustSignals::_internal_serial_number() const { … }
inline void DeviceTrustSignals::_internal_set_serial_number(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_serial_number() { … }
inline std::string* DeviceTrustSignals::release_serial_number() { … }
inline void DeviceTrustSignals::set_allocated_serial_number(std::string* serial_number) { … }

// optional string display_name = 4;
inline bool DeviceTrustSignals::_internal_has_display_name() const { … }
inline bool DeviceTrustSignals::has_display_name() const { … }
inline void DeviceTrustSignals::clear_display_name() { … }
inline const std::string& DeviceTrustSignals::display_name() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_display_name(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_display_name() { … }
inline const std::string& DeviceTrustSignals::_internal_display_name() const { … }
inline void DeviceTrustSignals::_internal_set_display_name(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_display_name() { … }
inline std::string* DeviceTrustSignals::release_display_name() { … }
inline void DeviceTrustSignals::set_allocated_display_name(std::string* display_name) { … }

// optional string os = 5;
inline bool DeviceTrustSignals::_internal_has_os() const { … }
inline bool DeviceTrustSignals::has_os() const { … }
inline void DeviceTrustSignals::clear_os() { … }
inline const std::string& DeviceTrustSignals::os() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_os(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_os() { … }
inline const std::string& DeviceTrustSignals::_internal_os() const { … }
inline void DeviceTrustSignals::_internal_set_os(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_os() { … }
inline std::string* DeviceTrustSignals::release_os() { … }
inline void DeviceTrustSignals::set_allocated_os(std::string* os) { … }

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

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

// optional string os_version = 8;
inline bool DeviceTrustSignals::_internal_has_os_version() const { … }
inline bool DeviceTrustSignals::has_os_version() const { … }
inline void DeviceTrustSignals::clear_os_version() { … }
inline const std::string& DeviceTrustSignals::os_version() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_os_version(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_os_version() { … }
inline const std::string& DeviceTrustSignals::_internal_os_version() const { … }
inline void DeviceTrustSignals::_internal_set_os_version(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_os_version() { … }
inline std::string* DeviceTrustSignals::release_os_version() { … }
inline void DeviceTrustSignals::set_allocated_os_version(std::string* os_version) { … }

// repeated string imei = 9;
inline int DeviceTrustSignals::_internal_imei_size() const { … }
inline int DeviceTrustSignals::imei_size() const { … }
inline void DeviceTrustSignals::clear_imei() { … }
inline std::string* DeviceTrustSignals::add_imei() { … }
inline const std::string& DeviceTrustSignals::_internal_imei(int index) const { … }
inline const std::string& DeviceTrustSignals::imei(int index) const { … }
inline std::string* DeviceTrustSignals::mutable_imei(int index) { … }
inline void DeviceTrustSignals::set_imei(int index, const std::string& value) { … }
inline void DeviceTrustSignals::set_imei(int index, std::string&& value) { … }
inline void DeviceTrustSignals::set_imei(int index, const char* value) { … }
inline void DeviceTrustSignals::set_imei(int index, const char* value, size_t size) { … }
inline std::string* DeviceTrustSignals::_internal_add_imei() { … }
inline void DeviceTrustSignals::add_imei(const std::string& value) { … }
inline void DeviceTrustSignals::add_imei(std::string&& value) { … }
inline void DeviceTrustSignals::add_imei(const char* value) { … }
inline void DeviceTrustSignals::add_imei(const char* value, size_t size) { … }
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceTrustSignals::imei() const { … }
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceTrustSignals::mutable_imei() { … }

// repeated string meid = 10;
inline int DeviceTrustSignals::_internal_meid_size() const { … }
inline int DeviceTrustSignals::meid_size() const { … }
inline void DeviceTrustSignals::clear_meid() { … }
inline std::string* DeviceTrustSignals::add_meid() { … }
inline const std::string& DeviceTrustSignals::_internal_meid(int index) const { … }
inline const std::string& DeviceTrustSignals::meid(int index) const { … }
inline std::string* DeviceTrustSignals::mutable_meid(int index) { … }
inline void DeviceTrustSignals::set_meid(int index, const std::string& value) { … }
inline void DeviceTrustSignals::set_meid(int index, std::string&& value) { … }
inline void DeviceTrustSignals::set_meid(int index, const char* value) { … }
inline void DeviceTrustSignals::set_meid(int index, const char* value, size_t size) { … }
inline std::string* DeviceTrustSignals::_internal_add_meid() { … }
inline void DeviceTrustSignals::add_meid(const std::string& value) { … }
inline void DeviceTrustSignals::add_meid(std::string&& value) { … }
inline void DeviceTrustSignals::add_meid(const char* value) { … }
inline void DeviceTrustSignals::add_meid(const char* value, size_t size) { … }
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceTrustSignals::meid() const { … }
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceTrustSignals::mutable_meid() { … }

// optional string tpm_hash = 11;
inline bool DeviceTrustSignals::_internal_has_tpm_hash() const { … }
inline bool DeviceTrustSignals::has_tpm_hash() const { … }
inline void DeviceTrustSignals::clear_tpm_hash() { … }
inline const std::string& DeviceTrustSignals::tpm_hash() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_tpm_hash(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_tpm_hash() { … }
inline const std::string& DeviceTrustSignals::_internal_tpm_hash() const { … }
inline void DeviceTrustSignals::_internal_set_tpm_hash(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_tpm_hash() { … }
inline std::string* DeviceTrustSignals::release_tpm_hash() { … }
inline void DeviceTrustSignals::set_allocated_tpm_hash(std::string* tpm_hash) { … }

// optional bool is_disk_encrypted = 12;
inline bool DeviceTrustSignals::_internal_has_is_disk_encrypted() const { … }
inline bool DeviceTrustSignals::has_is_disk_encrypted() const { … }
inline void DeviceTrustSignals::clear_is_disk_encrypted() { … }
inline bool DeviceTrustSignals::_internal_is_disk_encrypted() const { … }
inline bool DeviceTrustSignals::is_disk_encrypted() const { … }
inline void DeviceTrustSignals::_internal_set_is_disk_encrypted(bool value) { … }
inline void DeviceTrustSignals::set_is_disk_encrypted(bool value) { … }

// optional bool allow_screen_lock = 13;
inline bool DeviceTrustSignals::_internal_has_allow_screen_lock() const { … }
inline bool DeviceTrustSignals::has_allow_screen_lock() const { … }
inline void DeviceTrustSignals::clear_allow_screen_lock() { … }
inline bool DeviceTrustSignals::_internal_allow_screen_lock() const { … }
inline bool DeviceTrustSignals::allow_screen_lock() const { … }
inline void DeviceTrustSignals::_internal_set_allow_screen_lock(bool value) { … }
inline void DeviceTrustSignals::set_allow_screen_lock(bool value) { … }

// optional bool is_protected_by_password = 14;
inline bool DeviceTrustSignals::_internal_has_is_protected_by_password() const { … }
inline bool DeviceTrustSignals::has_is_protected_by_password() const { … }
inline void DeviceTrustSignals::clear_is_protected_by_password() { … }
inline bool DeviceTrustSignals::_internal_is_protected_by_password() const { … }
inline bool DeviceTrustSignals::is_protected_by_password() const { … }
inline void DeviceTrustSignals::_internal_set_is_protected_by_password(bool value) { … }
inline void DeviceTrustSignals::set_is_protected_by_password(bool value) { … }

// optional bool is_jailbroken = 15;
inline bool DeviceTrustSignals::_internal_has_is_jailbroken() const { … }
inline bool DeviceTrustSignals::has_is_jailbroken() const { … }
inline void DeviceTrustSignals::clear_is_jailbroken() { … }
inline bool DeviceTrustSignals::_internal_is_jailbroken() const { … }
inline bool DeviceTrustSignals::is_jailbroken() const { … }
inline void DeviceTrustSignals::_internal_set_is_jailbroken(bool value) { … }
inline void DeviceTrustSignals::set_is_jailbroken(bool value) { … }

// optional string enrollment_domain = 16;
inline bool DeviceTrustSignals::_internal_has_enrollment_domain() const { … }
inline bool DeviceTrustSignals::has_enrollment_domain() const { … }
inline void DeviceTrustSignals::clear_enrollment_domain() { … }
inline const std::string& DeviceTrustSignals::enrollment_domain() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_enrollment_domain(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_enrollment_domain() { … }
inline const std::string& DeviceTrustSignals::_internal_enrollment_domain() const { … }
inline void DeviceTrustSignals::_internal_set_enrollment_domain(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_enrollment_domain() { … }
inline std::string* DeviceTrustSignals::release_enrollment_domain() { … }
inline void DeviceTrustSignals::set_allocated_enrollment_domain(std::string* enrollment_domain) { … }

// optional string browser_version = 17;
inline bool DeviceTrustSignals::_internal_has_browser_version() const { … }
inline bool DeviceTrustSignals::has_browser_version() const { … }
inline void DeviceTrustSignals::clear_browser_version() { … }
inline const std::string& DeviceTrustSignals::browser_version() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_browser_version(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_browser_version() { … }
inline const std::string& DeviceTrustSignals::_internal_browser_version() const { … }
inline void DeviceTrustSignals::_internal_set_browser_version(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_browser_version() { … }
inline std::string* DeviceTrustSignals::release_browser_version() { … }
inline void DeviceTrustSignals::set_allocated_browser_version(std::string* browser_version) { … }

// optional int32 safe_browsing_protection_level = 18;
inline bool DeviceTrustSignals::_internal_has_safe_browsing_protection_level() const { … }
inline bool DeviceTrustSignals::has_safe_browsing_protection_level() const { … }
inline void DeviceTrustSignals::clear_safe_browsing_protection_level() { … }
inline int32_t DeviceTrustSignals::_internal_safe_browsing_protection_level() const { … }
inline int32_t DeviceTrustSignals::safe_browsing_protection_level() const { … }
inline void DeviceTrustSignals::_internal_set_safe_browsing_protection_level(int32_t value) { … }
inline void DeviceTrustSignals::set_safe_browsing_protection_level(int32_t value) { … }

// optional bool site_isolation_enabled = 19;
inline bool DeviceTrustSignals::_internal_has_site_isolation_enabled() const { … }
inline bool DeviceTrustSignals::has_site_isolation_enabled() const { … }
inline void DeviceTrustSignals::clear_site_isolation_enabled() { … }
inline bool DeviceTrustSignals::_internal_site_isolation_enabled() const { … }
inline bool DeviceTrustSignals::site_isolation_enabled() const { … }
inline void DeviceTrustSignals::_internal_set_site_isolation_enabled(bool value) { … }
inline void DeviceTrustSignals::set_site_isolation_enabled(bool value) { … }

// optional bool third_party_blocking_enabled = 20;
inline bool DeviceTrustSignals::_internal_has_third_party_blocking_enabled() const { … }
inline bool DeviceTrustSignals::has_third_party_blocking_enabled() const { … }
inline void DeviceTrustSignals::clear_third_party_blocking_enabled() { … }
inline bool DeviceTrustSignals::_internal_third_party_blocking_enabled() const { … }
inline bool DeviceTrustSignals::third_party_blocking_enabled() const { … }
inline void DeviceTrustSignals::_internal_set_third_party_blocking_enabled(bool value) { … }
inline void DeviceTrustSignals::set_third_party_blocking_enabled(bool value) { … }

// optional bool remote_desktop_available = 21;
inline bool DeviceTrustSignals::_internal_has_remote_desktop_available() const { … }
inline bool DeviceTrustSignals::has_remote_desktop_available() const { … }
inline void DeviceTrustSignals::clear_remote_desktop_available() { … }
inline bool DeviceTrustSignals::_internal_remote_desktop_available() const { … }
inline bool DeviceTrustSignals::remote_desktop_available() const { … }
inline void DeviceTrustSignals::_internal_set_remote_desktop_available(bool value) { … }
inline void DeviceTrustSignals::set_remote_desktop_available(bool value) { … }

// optional string signed_in_profile_name = 22;
inline bool DeviceTrustSignals::_internal_has_signed_in_profile_name() const { … }
inline bool DeviceTrustSignals::has_signed_in_profile_name() const { … }
inline void DeviceTrustSignals::clear_signed_in_profile_name() { … }
inline const std::string& DeviceTrustSignals::signed_in_profile_name() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_signed_in_profile_name(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_signed_in_profile_name() { … }
inline const std::string& DeviceTrustSignals::_internal_signed_in_profile_name() const { … }
inline void DeviceTrustSignals::_internal_set_signed_in_profile_name(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_signed_in_profile_name() { … }
inline std::string* DeviceTrustSignals::release_signed_in_profile_name() { … }
inline void DeviceTrustSignals::set_allocated_signed_in_profile_name(std::string* signed_in_profile_name) { … }

// optional bool chrome_cleanup_enabled = 23;
inline bool DeviceTrustSignals::_internal_has_chrome_cleanup_enabled() const { … }
inline bool DeviceTrustSignals::has_chrome_cleanup_enabled() const { … }
inline void DeviceTrustSignals::clear_chrome_cleanup_enabled() { … }
inline bool DeviceTrustSignals::_internal_chrome_cleanup_enabled() const { … }
inline bool DeviceTrustSignals::chrome_cleanup_enabled() const { … }
inline void DeviceTrustSignals::_internal_set_chrome_cleanup_enabled(bool value) { … }
inline void DeviceTrustSignals::set_chrome_cleanup_enabled(bool value) { … }

// optional int32 password_protection_warning_trigger = 24;
inline bool DeviceTrustSignals::_internal_has_password_protection_warning_trigger() const { … }
inline bool DeviceTrustSignals::has_password_protection_warning_trigger() const { … }
inline void DeviceTrustSignals::clear_password_protection_warning_trigger() { … }
inline int32_t DeviceTrustSignals::_internal_password_protection_warning_trigger() const { … }
inline int32_t DeviceTrustSignals::password_protection_warning_trigger() const { … }
inline void DeviceTrustSignals::_internal_set_password_protection_warning_trigger(int32_t value) { … }
inline void DeviceTrustSignals::set_password_protection_warning_trigger(int32_t value) { … }

// optional string dns_address = 25;
inline bool DeviceTrustSignals::_internal_has_dns_address() const { … }
inline bool DeviceTrustSignals::has_dns_address() const { … }
inline void DeviceTrustSignals::clear_dns_address() { … }
inline const std::string& DeviceTrustSignals::dns_address() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_dns_address(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_dns_address() { … }
inline const std::string& DeviceTrustSignals::_internal_dns_address() const { … }
inline void DeviceTrustSignals::_internal_set_dns_address(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_dns_address() { … }
inline std::string* DeviceTrustSignals::release_dns_address() { … }
inline void DeviceTrustSignals::set_allocated_dns_address(std::string* dns_address) { … }

// optional bool built_in_dns_client_enabled = 26;
inline bool DeviceTrustSignals::_internal_has_built_in_dns_client_enabled() const { … }
inline bool DeviceTrustSignals::has_built_in_dns_client_enabled() const { … }
inline void DeviceTrustSignals::clear_built_in_dns_client_enabled() { … }
inline bool DeviceTrustSignals::_internal_built_in_dns_client_enabled() const { … }
inline bool DeviceTrustSignals::built_in_dns_client_enabled() const { … }
inline void DeviceTrustSignals::_internal_set_built_in_dns_client_enabled(bool value) { … }
inline void DeviceTrustSignals::set_built_in_dns_client_enabled(bool value) { … }

// optional bool firewall_on = 27;
inline bool DeviceTrustSignals::_internal_has_firewall_on() const { … }
inline bool DeviceTrustSignals::has_firewall_on() const { … }
inline void DeviceTrustSignals::clear_firewall_on() { … }
inline bool DeviceTrustSignals::_internal_firewall_on() const { … }
inline bool DeviceTrustSignals::firewall_on() const { … }
inline void DeviceTrustSignals::_internal_set_firewall_on(bool value) { … }
inline void DeviceTrustSignals::set_firewall_on(bool value) { … }

// optional string windows_domain = 28;
inline bool DeviceTrustSignals::_internal_has_windows_domain() const { … }
inline bool DeviceTrustSignals::has_windows_domain() const { … }
inline void DeviceTrustSignals::clear_windows_domain() { … }
inline const std::string& DeviceTrustSignals::windows_domain() const { … }
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceTrustSignals::set_windows_domain(ArgT0&& arg0, ArgT... args) { … }
inline std::string* DeviceTrustSignals::mutable_windows_domain() { … }
inline const std::string& DeviceTrustSignals::_internal_windows_domain() const { … }
inline void DeviceTrustSignals::_internal_set_windows_domain(const std::string& value) { … }
inline std::string* DeviceTrustSignals::_internal_mutable_windows_domain() { … }
inline std::string* DeviceTrustSignals::release_windows_domain() { … }
inline void DeviceTrustSignals::set_allocated_windows_domain(std::string* windows_domain) { … }

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace enterprise_connectors

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::enterprise_connectors::VerifiedAccessFlow> : ::std::true_type { … };

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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