// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/public/device_common.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3017000
#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 3017003 < 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/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcommon_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_protos_2fpublic_2fdevice_5fcommon_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 ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fcommon_2eproto;
namespace video_widevine {
class AndroidAttestationKeybox;
struct AndroidAttestationKeyboxDefaultTypeInternal;
extern AndroidAttestationKeyboxDefaultTypeInternal _AndroidAttestationKeybox_default_instance_;
class DeviceModel;
struct DeviceModelDefaultTypeInternal;
extern DeviceModelDefaultTypeInternal _DeviceModel_default_instance_;
class VerificationInfo;
struct VerificationInfoDefaultTypeInternal;
extern VerificationInfoDefaultTypeInternal _VerificationInfo_default_instance_;
class VulnerabilityInfo;
struct VulnerabilityInfoDefaultTypeInternal;
extern VulnerabilityInfoDefaultTypeInternal _VulnerabilityInfo_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::AndroidAttestationKeybox* Arena::CreateMaybeMessage<::video_widevine::AndroidAttestationKeybox>(Arena*);
template<> ::video_widevine::DeviceModel* Arena::CreateMaybeMessage<::video_widevine::DeviceModel>(Arena*);
template<> ::video_widevine::VerificationInfo* Arena::CreateMaybeMessage<::video_widevine::VerificationInfo>(Arena*);
template<> ::video_widevine::VulnerabilityInfo* Arena::CreateMaybeMessage<::video_widevine::VulnerabilityInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum DeviceModel_ModelStatus : int {
  DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED = 0,
  DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED = 1,
  DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED = 2,
  DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN = 4,
  DeviceModel_ModelStatus_MODEL_STATUS_REJECTED = 3,
  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DeviceModel_ModelStatus_IsValid(int value);
constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MIN = DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MAX = DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
constexpr int DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE = DeviceModel_ModelStatus_ModelStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceModel_ModelStatus_descriptor();
template<typename T>
inline const std::string& DeviceModel_ModelStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceModel_ModelStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceModel_ModelStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceModel_ModelStatus_descriptor(), enum_t_value);
}
inline bool DeviceModel_ModelStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceModel_ModelStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceModel_ModelStatus>(
    DeviceModel_ModelStatus_descriptor(), name, value);
}
enum DeviceState : int {
  DEVICE_STATE_UNKNOWN = 0,
  IN_TESTING = 1,
  RELEASED = 2,
  DELETED = 3,
  TEST_ONLY = 4,
  REVOKED = 5,
  PRE_RELEASE = 6,
  REVOKED_LICENSING = 7,
  DeviceState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DeviceState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DeviceState_IsValid(int value);
constexpr DeviceState DeviceState_MIN = DEVICE_STATE_UNKNOWN;
constexpr DeviceState DeviceState_MAX = REVOKED_LICENSING;
constexpr int DeviceState_ARRAYSIZE = DeviceState_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceState_descriptor();
template<typename T>
inline const std::string& DeviceState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceState_descriptor(), enum_t_value);
}
inline bool DeviceState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceState>(
    DeviceState_descriptor(), name, value);
}
enum DeviceType : int {
  DEVICE_TYPE_UNSPECIFIED = 0,
  DEVICE_TYPE_PHONE = 1,
  DEVICE_TYPE_TV = 2,
  DEVICE_TYPE_TABLET = 3,
  DEVICE_TYPE_GAMING_CONSOLE = 4,
  DEVICE_TYPE_SET_TOP_BOX = 5,
  DEVICE_TYPE_VIDEO_DONGLE = 6,
  DEVICE_TYPE_PC = 7,
  DEVICE_TYPE_AUTO = 8,
  DEVICE_TYPE_WEARABLE = 9,
  DEVICE_TYPE_CONNECTED_AUDIO_DEVICE = 10,
  DEVICE_TYPE_SMART_DISPLAY = 11,
  DEVICE_TYPE_SOC = 12,
  DeviceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DeviceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DeviceType_IsValid(int value);
constexpr DeviceType DeviceType_MIN = DEVICE_TYPE_UNSPECIFIED;
constexpr DeviceType DeviceType_MAX = DEVICE_TYPE_SOC;
constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceType_descriptor();
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 ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceType_descriptor(), enum_t_value);
}
inline bool DeviceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceType>(
    DeviceType_descriptor(), name, value);
}
enum Platform : int {
  PLATFORM_UNSPECIFIED = 0,
  PLATFORM_CHROMECAST = 1,
  PLATFORM_FUCHSIA = 2,
  PLATFORM_IOS = 3,
  PLATFORM_IPAD_OS = 4,
  PLATFORM_TV_OS = 5,
  PLATFORM_ANDROID = 6,
  PLATFORM_WINDOWS = 7,
  PLATFORM_CHROME_OS = 8,
  PLATFORM_MAC_OS = 9,
  PLATFORM_LINUX = 10,
  PLATFORM_WEB_OS = 11,
  PLATFORM_TIZEN = 12,
  PLATFORM_FIRE_OS = 13,
  PLATFORM_ROKU = 14,
  PLATFORM_PLAYSTATION = 15,
  PLATFORM_XBOX = 16,
  PLATFORM_KAIOS = 17,
  PLATFORM_RDK = 18,
  PLATFORM_OTHER = 19,
  Platform_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Platform_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Platform_IsValid(int value);
constexpr Platform Platform_MIN = PLATFORM_UNSPECIFIED;
constexpr Platform Platform_MAX = PLATFORM_OTHER;
constexpr int Platform_ARRAYSIZE = Platform_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Platform_descriptor();
template<typename T>
inline const std::string& Platform_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Platform>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Platform_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Platform_descriptor(), enum_t_value);
}
inline bool Platform_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Platform* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Platform>(
    Platform_descriptor(), name, value);
}
enum OsOptionalSupport : int {
  OS_OPTIONAL_SUPPORT_UNSPECIFIED = 0,
  YES_TEE = 1,
  YES_REE = 2,
  NO_SUPPORT = 3,
  OsOptionalSupport_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  OsOptionalSupport_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool OsOptionalSupport_IsValid(int value);
constexpr OsOptionalSupport OsOptionalSupport_MIN = OS_OPTIONAL_SUPPORT_UNSPECIFIED;
constexpr OsOptionalSupport OsOptionalSupport_MAX = NO_SUPPORT;
constexpr int OsOptionalSupport_ARRAYSIZE = OsOptionalSupport_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OsOptionalSupport_descriptor();
template<typename T>
inline const std::string& OsOptionalSupport_Name(T enum_t_value) {
  static_assert(::std::is_same<T, OsOptionalSupport>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function OsOptionalSupport_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    OsOptionalSupport_descriptor(), enum_t_value);
}
inline bool OsOptionalSupport_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OsOptionalSupport* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OsOptionalSupport>(
    OsOptionalSupport_descriptor(), name, value);
}
enum HdcpVersion : int {
  HDCP_VERSION_UNSPECIFIED = 0,
  HDCP_V1 = 1,
  HDCP_V2 = 2,
  HDCP_V2_1 = 3,
  HDCP_V2_2 = 4,
  HDCP_V2_3 = 5,
  HDCP_V1_0 = 6,
  HDCP_V1_1 = 7,
  HDCP_V1_2 = 8,
  HDCP_V1_3 = 9,
  HDCP_V1_4 = 10,
  HdcpVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  HdcpVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool HdcpVersion_IsValid(int value);
constexpr HdcpVersion HdcpVersion_MIN = HDCP_VERSION_UNSPECIFIED;
constexpr HdcpVersion HdcpVersion_MAX = HDCP_V1_4;
constexpr int HdcpVersion_ARRAYSIZE = HdcpVersion_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HdcpVersion_descriptor();
template<typename T>
inline const std::string& HdcpVersion_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HdcpVersion>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HdcpVersion_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HdcpVersion_descriptor(), enum_t_value);
}
inline bool HdcpVersion_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HdcpVersion* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HdcpVersion>(
    HdcpVersion_descriptor(), name, value);
}
enum DeviceSecurityLevel : int {
  SECURITY_LEVEL_UNSPECIFIED = 0,
  LEVEL_1 = 1,
  LEVEL_2 = 2,
  LEVEL_3 = 3,
  DeviceSecurityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  DeviceSecurityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool DeviceSecurityLevel_IsValid(int value);
constexpr DeviceSecurityLevel DeviceSecurityLevel_MIN = SECURITY_LEVEL_UNSPECIFIED;
constexpr DeviceSecurityLevel DeviceSecurityLevel_MAX = LEVEL_3;
constexpr int DeviceSecurityLevel_ARRAYSIZE = DeviceSecurityLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceSecurityLevel_descriptor();
template<typename T>
inline const std::string& DeviceSecurityLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceSecurityLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceSecurityLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceSecurityLevel_descriptor(), enum_t_value);
}
inline bool DeviceSecurityLevel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceSecurityLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceSecurityLevel>(
    DeviceSecurityLevel_descriptor(), name, value);
}
enum CertificateKeyType : int {
  CERTIFICATE_KEY_TYPE_UNSPECIFIED = 0,
  CERTIFICATE_KEY_TYPE_RSA = 1,
  CERTIFICATE_KEY_TYPE_RSA_EULER = 2,
  CERTIFICATE_KEY_TYPE_EC = 3,
  CertificateKeyType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CertificateKeyType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CertificateKeyType_IsValid(int value);
constexpr CertificateKeyType CertificateKeyType_MIN = CERTIFICATE_KEY_TYPE_UNSPECIFIED;
constexpr CertificateKeyType CertificateKeyType_MAX = CERTIFICATE_KEY_TYPE_EC;
constexpr int CertificateKeyType_ARRAYSIZE = CertificateKeyType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CertificateKeyType_descriptor();
template<typename T>
inline const std::string& CertificateKeyType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CertificateKeyType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CertificateKeyType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CertificateKeyType_descriptor(), enum_t_value);
}
inline bool CertificateKeyType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CertificateKeyType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CertificateKeyType>(
    CertificateKeyType_descriptor(), name, value);
}
enum RSAKeySize : int {
  RSA_KEY_SIZE_UNSPECIFIED = 0,
  RSA_KEY_SIZE_1024 = 1,
  RSA_KEY_SIZE_2048 = 2,
  RSA_KEY_SIZE_3072 = 3,
  RSA_KEY_SIZE_4096 = 4,
  RSAKeySize_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RSAKeySize_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RSAKeySize_IsValid(int value);
constexpr RSAKeySize RSAKeySize_MIN = RSA_KEY_SIZE_UNSPECIFIED;
constexpr RSAKeySize RSAKeySize_MAX = RSA_KEY_SIZE_4096;
constexpr int RSAKeySize_ARRAYSIZE = RSAKeySize_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RSAKeySize_descriptor();
template<typename T>
inline const std::string& RSAKeySize_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RSAKeySize>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RSAKeySize_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RSAKeySize_descriptor(), enum_t_value);
}
inline bool RSAKeySize_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RSAKeySize* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RSAKeySize>(
    RSAKeySize_descriptor(), name, value);
}
enum VulnerabilityLevel : int {
  VULNERABILITY_LEVEL_UNSPECIFIED = 0,
  VULNERABILITY_LEVEL_NONE = 1,
  VULNERABILITY_LEVEL_LOW = 2,
  VULNERABILITY_LEVEL_MEDIUM = 3,
  VULNERABILITY_LEVEL_HIGH = 4,
  VULNERABILITY_LEVEL_CRITICAL = 5,
  VulnerabilityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  VulnerabilityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool VulnerabilityLevel_IsValid(int value);
constexpr VulnerabilityLevel VulnerabilityLevel_MIN = VULNERABILITY_LEVEL_UNSPECIFIED;
constexpr VulnerabilityLevel VulnerabilityLevel_MAX = VULNERABILITY_LEVEL_CRITICAL;
constexpr int VulnerabilityLevel_ARRAYSIZE = VulnerabilityLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VulnerabilityLevel_descriptor();
template<typename T>
inline const std::string& VulnerabilityLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VulnerabilityLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VulnerabilityLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    VulnerabilityLevel_descriptor(), enum_t_value);
}
inline bool VulnerabilityLevel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VulnerabilityLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VulnerabilityLevel>(
    VulnerabilityLevel_descriptor(), name, value);
}
enum VerificationLevel : int {
  VERIFICATION_LEVEL_UNSPECIFIED = 0,
  VERIFICATION_LEVEL_UNVERIFIED = 1,
  VERIFICATION_LEVEL_VERIFIED = 2,
  VERIFICATION_LEVEL_VERIFIED_GTS = 3,
  VerificationLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  VerificationLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool VerificationLevel_IsValid(int value);
constexpr VerificationLevel VerificationLevel_MIN = VERIFICATION_LEVEL_UNSPECIFIED;
constexpr VerificationLevel VerificationLevel_MAX = VERIFICATION_LEVEL_VERIFIED_GTS;
constexpr int VerificationLevel_ARRAYSIZE = VerificationLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VerificationLevel_descriptor();
template<typename T>
inline const std::string& VerificationLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VerificationLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VerificationLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    VerificationLevel_descriptor(), enum_t_value);
}
inline bool VerificationLevel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VerificationLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VerificationLevel>(
    VerificationLevel_descriptor(), name, value);
}
// ===================================================================

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

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

  inline DeviceModel& operator=(const DeviceModel& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceModel& operator=(DeviceModel&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DeviceModel& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeviceModel* internal_default_instance() {
    return reinterpret_cast<const DeviceModel*>(
               &_DeviceModel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(DeviceModel& a, DeviceModel& b) {
    a.Swap(&b);
  }
  inline void Swap(DeviceModel* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeviceModel* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline DeviceModel* New() const final {
    return new DeviceModel();
  }

  DeviceModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceModel>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceModel& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceModel& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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 final;
  void InternalSwap(DeviceModel* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceModel";
  }
  protected:
  explicit DeviceModel(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef DeviceModel_ModelStatus ModelStatus;
  static constexpr ModelStatus MODEL_STATUS_UNSPECIFIED =
    DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
  static constexpr ModelStatus MODEL_STATUS_VERIFIED =
    DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED;
  static constexpr ModelStatus MODEL_STATUS_UNVERIFIED =
    DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED;
  static constexpr ModelStatus MODEL_STATUS_UNKNOWN =
    DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
  static constexpr ModelStatus MODEL_STATUS_REJECTED =
    DeviceModel_ModelStatus_MODEL_STATUS_REJECTED;
  static inline bool ModelStatus_IsValid(int value) {
    return DeviceModel_ModelStatus_IsValid(value);
  }
  static constexpr ModelStatus ModelStatus_MIN =
    DeviceModel_ModelStatus_ModelStatus_MIN;
  static constexpr ModelStatus ModelStatus_MAX =
    DeviceModel_ModelStatus_ModelStatus_MAX;
  static constexpr int ModelStatus_ARRAYSIZE =
    DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ModelStatus_descriptor() {
    return DeviceModel_ModelStatus_descriptor();
  }
  template<typename T>
  static inline const std::string& ModelStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ModelStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ModelStatus_Name.");
    return DeviceModel_ModelStatus_Name(enum_t_value);
  }
  static inline bool ModelStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ModelStatus* value) {
    return DeviceModel_ModelStatus_Parse(name, value);
  }

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

  enum : int {
    kManufacturerFieldNumber = 1,
    kModelNameFieldNumber = 2,
    kModelYearFieldNumber = 3,
    kStatusFieldNumber = 4,
  };
  // string manufacturer = 1;
  void clear_manufacturer();
  const std::string& manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manufacturer();
  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
  void set_allocated_manufacturer(std::string* manufacturer);
  private:
  const std::string& _internal_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
  std::string* _internal_mutable_manufacturer();
  public:

  // string model_name = 2;
  void clear_model_name();
  const std::string& model_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_model_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_model_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_model_name();
  void set_allocated_model_name(std::string* model_name);
  private:
  const std::string& _internal_model_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
  std::string* _internal_mutable_model_name();
  public:

  // uint32 model_year = 3;
  void clear_model_year();
  ::PROTOBUF_NAMESPACE_ID::uint32 model_year() const;
  void set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_model_year() const;
  void _internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .video_widevine.DeviceModel.ModelStatus status = 4;
  void clear_status();
  ::video_widevine::DeviceModel_ModelStatus status() const;
  void set_status(::video_widevine::DeviceModel_ModelStatus value);
  private:
  ::video_widevine::DeviceModel_ModelStatus _internal_status() const;
  void _internal_set_status(::video_widevine::DeviceModel_ModelStatus value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceModel)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_name_;
  ::PROTOBUF_NAMESPACE_ID::uint32 model_year_;
  int status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline VulnerabilityInfo& operator=(const VulnerabilityInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline VulnerabilityInfo& operator=(VulnerabilityInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VulnerabilityInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const VulnerabilityInfo* internal_default_instance() {
    return reinterpret_cast<const VulnerabilityInfo*>(
               &_VulnerabilityInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(VulnerabilityInfo& a, VulnerabilityInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(VulnerabilityInfo* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VulnerabilityInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline VulnerabilityInfo* New() const final {
    return new VulnerabilityInfo();
  }

  VulnerabilityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VulnerabilityInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VulnerabilityInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const VulnerabilityInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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 final;
  void InternalSwap(VulnerabilityInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.VulnerabilityInfo";
  }
  protected:
  explicit VulnerabilityInfo(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDescriptionFieldNumber = 1,
    kBuganizerNumberFieldNumber = 2,
    kVulnerabilityLevelFieldNumber = 3,
  };
  // string description = 1;
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_MUST_USE_RESULT std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // uint64 buganizer_number = 2;
  void clear_buganizer_number();
  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number() const;
  void set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_buganizer_number() const;
  void _internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // .video_widevine.VulnerabilityLevel vulnerability_level = 3;
  void clear_vulnerability_level();
  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
  private:
  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.VulnerabilityInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number_;
  int vulnerability_level_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline VerificationInfo& operator=(const VerificationInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline VerificationInfo& operator=(VerificationInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VerificationInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const VerificationInfo* internal_default_instance() {
    return reinterpret_cast<const VerificationInfo*>(
               &_VerificationInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(VerificationInfo& a, VerificationInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(VerificationInfo* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VerificationInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline VerificationInfo* New() const final {
    return new VerificationInfo();
  }

  VerificationInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VerificationInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VerificationInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const VerificationInfo& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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 final;
  void InternalSwap(VerificationInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.VerificationInfo";
  }
  protected:
  explicit VerificationInfo(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kProofFieldNumber = 2,
    kNotesFieldNumber = 3,
    kLevelFieldNumber = 1,
  };
  // string proof = 2;
  void clear_proof();
  const std::string& proof() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_proof(ArgT0&& arg0, ArgT... args);
  std::string* mutable_proof();
  PROTOBUF_MUST_USE_RESULT std::string* release_proof();
  void set_allocated_proof(std::string* proof);
  private:
  const std::string& _internal_proof() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_proof(const std::string& value);
  std::string* _internal_mutable_proof();
  public:

  // string notes = 3;
  void clear_notes();
  const std::string& notes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_notes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_notes();
  PROTOBUF_MUST_USE_RESULT std::string* release_notes();
  void set_allocated_notes(std::string* notes);
  private:
  const std::string& _internal_notes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_notes(const std::string& value);
  std::string* _internal_mutable_notes();
  public:

  // .video_widevine.VerificationLevel level = 1;
  void clear_level();
  ::video_widevine::VerificationLevel level() const;
  void set_level(::video_widevine::VerificationLevel value);
  private:
  ::video_widevine::VerificationLevel _internal_level() const;
  void _internal_set_level(::video_widevine::VerificationLevel value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.VerificationInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr proof_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr notes_;
  int level_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline AndroidAttestationKeybox& operator=(const AndroidAttestationKeybox& from) {
    CopyFrom(from);
    return *this;
  }
  inline AndroidAttestationKeybox& operator=(AndroidAttestationKeybox&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AndroidAttestationKeybox& default_instance() {
    return *internal_default_instance();
  }
  static inline const AndroidAttestationKeybox* internal_default_instance() {
    return reinterpret_cast<const AndroidAttestationKeybox*>(
               &_AndroidAttestationKeybox_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(AndroidAttestationKeybox& a, AndroidAttestationKeybox& b) {
    a.Swap(&b);
  }
  inline void Swap(AndroidAttestationKeybox* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AndroidAttestationKeybox* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  inline AndroidAttestationKeybox* New() const final {
    return new AndroidAttestationKeybox();
  }

  AndroidAttestationKeybox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AndroidAttestationKeybox>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AndroidAttestationKeybox& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const AndroidAttestationKeybox& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
  public:
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* 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 final;
  void InternalSwap(AndroidAttestationKeybox* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.AndroidAttestationKeybox";
  }
  protected:
  explicit AndroidAttestationKeybox(::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:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kEcdsaCertFieldNumber = 2,
    kRsaCertFieldNumber = 4,
    kEcdsaPrivateKeyFieldNumber = 1,
    kRsaPrivateKeyFieldNumber = 3,
    kAttestationKeyboxIdFieldNumber = 5,
  };
  // repeated bytes ecdsa_cert = 2;
  int ecdsa_cert_size() const;
  private:
  int _internal_ecdsa_cert_size() const;
  public:
  void clear_ecdsa_cert();
  const std::string& ecdsa_cert(int index) const;
  std::string* mutable_ecdsa_cert(int index);
  void set_ecdsa_cert(int index, const std::string& value);
  void set_ecdsa_cert(int index, std::string&& value);
  void set_ecdsa_cert(int index, const char* value);
  void set_ecdsa_cert(int index, const void* value, size_t size);
  std::string* add_ecdsa_cert();
  void add_ecdsa_cert(const std::string& value);
  void add_ecdsa_cert(std::string&& value);
  void add_ecdsa_cert(const char* value);
  void add_ecdsa_cert(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& ecdsa_cert() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_ecdsa_cert();
  private:
  const std::string& _internal_ecdsa_cert(int index) const;
  std::string* _internal_add_ecdsa_cert();
  public:

  // repeated bytes rsa_cert = 4;
  int rsa_cert_size() const;
  private:
  int _internal_rsa_cert_size() const;
  public:
  void clear_rsa_cert();
  const std::string& rsa_cert(int index) const;
  std::string* mutable_rsa_cert(int index);
  void set_rsa_cert(int index, const std::string& value);
  void set_rsa_cert(int index, std::string&& value);
  void set_rsa_cert(int index, const char* value);
  void set_rsa_cert(int index, const void* value, size_t size);
  std::string* add_rsa_cert();
  void add_rsa_cert(const std::string& value);
  void add_rsa_cert(std::string&& value);
  void add_rsa_cert(const char* value);
  void add_rsa_cert(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& rsa_cert() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_rsa_cert();
  private:
  const std::string& _internal_rsa_cert(int index) const;
  std::string* _internal_add_rsa_cert();
  public:

  // bytes ecdsa_private_key = 1;
  void clear_ecdsa_private_key();
  const std::string& ecdsa_private_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ecdsa_private_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ecdsa_private_key();
  PROTOBUF_MUST_USE_RESULT std::string* release_ecdsa_private_key();
  void set_allocated_ecdsa_private_key(std::string* ecdsa_private_key);
  private:
  const std::string& _internal_ecdsa_private_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ecdsa_private_key(const std::string& value);
  std::string* _internal_mutable_ecdsa_private_key();
  public:

  // bytes rsa_private_key = 3;
  void clear_rsa_private_key();
  const std::string& rsa_private_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rsa_private_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rsa_private_key();
  PROTOBUF_MUST_USE_RESULT std::string* release_rsa_private_key();
  void set_allocated_rsa_private_key(std::string* rsa_private_key);
  private:
  const std::string& _internal_rsa_private_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsa_private_key(const std::string& value);
  std::string* _internal_mutable_rsa_private_key();
  public:

  // uint32 attestation_keybox_id = 5;
  void clear_attestation_keybox_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 attestation_keybox_id() const;
  void set_attestation_keybox_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_attestation_keybox_id() const;
  void _internal_set_attestation_keybox_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.AndroidAttestationKeybox)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> ecdsa_cert_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> rsa_cert_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecdsa_private_key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsa_private_key_;
  ::PROTOBUF_NAMESPACE_ID::uint32 attestation_keybox_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
};
// ===================================================================


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

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

// string manufacturer = 1;
inline void DeviceModel::clear_manufacturer() {
  manufacturer_.ClearToEmpty();
}
inline const std::string& DeviceModel::manufacturer() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.manufacturer)
  return _internal_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceModel::set_manufacturer(ArgT0&& arg0, ArgT... args) {
 
 manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.manufacturer)
}
inline std::string* DeviceModel::mutable_manufacturer() {
  std::string* _s = _internal_mutable_manufacturer();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.manufacturer)
  return _s;
}
inline const std::string& DeviceModel::_internal_manufacturer() const {
  return manufacturer_.Get();
}
inline void DeviceModel::_internal_set_manufacturer(const std::string& value) {
  
  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceModel::_internal_mutable_manufacturer() {
  
  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceModel::release_manufacturer() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.manufacturer)
  return manufacturer_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceModel::set_allocated_manufacturer(std::string* manufacturer) {
  if (manufacturer != nullptr) {
    
  } else {
    
  }
  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.manufacturer)
}

// string model_name = 2;
inline void DeviceModel::clear_model_name() {
  model_name_.ClearToEmpty();
}
inline const std::string& DeviceModel::model_name() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_name)
  return _internal_model_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceModel::set_model_name(ArgT0&& arg0, ArgT... args) {
 
 model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_name)
}
inline std::string* DeviceModel::mutable_model_name() {
  std::string* _s = _internal_mutable_model_name();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.model_name)
  return _s;
}
inline const std::string& DeviceModel::_internal_model_name() const {
  return model_name_.Get();
}
inline void DeviceModel::_internal_set_model_name(const std::string& value) {
  
  model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceModel::_internal_mutable_model_name() {
  
  return model_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceModel::release_model_name() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.model_name)
  return model_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceModel::set_allocated_model_name(std::string* model_name) {
  if (model_name != nullptr) {
    
  } else {
    
  }
  model_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.model_name)
}

// uint32 model_year = 3;
inline void DeviceModel::clear_model_year() {
  model_year_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::_internal_model_year() const {
  return model_year_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::model_year() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_year)
  return _internal_model_year();
}
inline void DeviceModel::_internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  model_year_ = value;
}
inline void DeviceModel::set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_model_year(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_year)
}

// .video_widevine.DeviceModel.ModelStatus status = 4;
inline void DeviceModel::clear_status() {
  status_ = 0;
}
inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::_internal_status() const {
  return static_cast< ::video_widevine::DeviceModel_ModelStatus >(status_);
}
inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::status() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.status)
  return _internal_status();
}
inline void DeviceModel::_internal_set_status(::video_widevine::DeviceModel_ModelStatus value) {
  
  status_ = value;
}
inline void DeviceModel::set_status(::video_widevine::DeviceModel_ModelStatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.status)
}

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

// VulnerabilityInfo

// string description = 1;
inline void VulnerabilityInfo::clear_description() {
  description_.ClearToEmpty();
}
inline const std::string& VulnerabilityInfo::description() const {
  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VulnerabilityInfo::set_description(ArgT0&& arg0, ArgT... args) {
 
 description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.description)
}
inline std::string* VulnerabilityInfo::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:video_widevine.VulnerabilityInfo.description)
  return _s;
}
inline const std::string& VulnerabilityInfo::_internal_description() const {
  return description_.Get();
}
inline void VulnerabilityInfo::_internal_set_description(const std::string& value) {
  
  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* VulnerabilityInfo::_internal_mutable_description() {
  
  return description_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* VulnerabilityInfo::release_description() {
  // @@protoc_insertion_point(field_release:video_widevine.VulnerabilityInfo.description)
  return description_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void VulnerabilityInfo::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.VulnerabilityInfo.description)
}

// uint64 buganizer_number = 2;
inline void VulnerabilityInfo::clear_buganizer_number() {
  buganizer_number_ = uint64_t{0u};
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::_internal_buganizer_number() const {
  return buganizer_number_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::buganizer_number() const {
  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.buganizer_number)
  return _internal_buganizer_number();
}
inline void VulnerabilityInfo::_internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  buganizer_number_ = value;
}
inline void VulnerabilityInfo::set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_buganizer_number(value);
  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.buganizer_number)
}

// .video_widevine.VulnerabilityLevel vulnerability_level = 3;
inline void VulnerabilityInfo::clear_vulnerability_level() {
  vulnerability_level_ = 0;
}
inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::_internal_vulnerability_level() const {
  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
}
inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::vulnerability_level() const {
  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.vulnerability_level)
  return _internal_vulnerability_level();
}
inline void VulnerabilityInfo::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
  
  vulnerability_level_ = value;
}
inline void VulnerabilityInfo::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
  _internal_set_vulnerability_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.vulnerability_level)
}

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

// VerificationInfo

// .video_widevine.VerificationLevel level = 1;
inline void VerificationInfo::clear_level() {
  level_ = 0;
}
inline ::video_widevine::VerificationLevel VerificationInfo::_internal_level() const {
  return static_cast< ::video_widevine::VerificationLevel >(level_);
}
inline ::video_widevine::VerificationLevel VerificationInfo::level() const {
  // @@protoc_insertion_point(field_get:video_widevine.VerificationInfo.level)
  return _internal_level();
}
inline void VerificationInfo::_internal_set_level(::video_widevine::VerificationLevel value) {
  
  level_ = value;
}
inline void VerificationInfo::set_level(::video_widevine::VerificationLevel value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.VerificationInfo.level)
}

// string proof = 2;
inline void VerificationInfo::clear_proof() {
  proof_.ClearToEmpty();
}
inline const std::string& VerificationInfo::proof() const {
  // @@protoc_insertion_point(field_get:video_widevine.VerificationInfo.proof)
  return _internal_proof();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerificationInfo::set_proof(ArgT0&& arg0, ArgT... args) {
 
 proof_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.VerificationInfo.proof)
}
inline std::string* VerificationInfo::mutable_proof() {
  std::string* _s = _internal_mutable_proof();
  // @@protoc_insertion_point(field_mutable:video_widevine.VerificationInfo.proof)
  return _s;
}
inline const std::string& VerificationInfo::_internal_proof() const {
  return proof_.Get();
}
inline void VerificationInfo::_internal_set_proof(const std::string& value) {
  
  proof_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* VerificationInfo::_internal_mutable_proof() {
  
  return proof_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* VerificationInfo::release_proof() {
  // @@protoc_insertion_point(field_release:video_widevine.VerificationInfo.proof)
  return proof_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void VerificationInfo::set_allocated_proof(std::string* proof) {
  if (proof != nullptr) {
    
  } else {
    
  }
  proof_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), proof,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.VerificationInfo.proof)
}

// string notes = 3;
inline void VerificationInfo::clear_notes() {
  notes_.ClearToEmpty();
}
inline const std::string& VerificationInfo::notes() const {
  // @@protoc_insertion_point(field_get:video_widevine.VerificationInfo.notes)
  return _internal_notes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerificationInfo::set_notes(ArgT0&& arg0, ArgT... args) {
 
 notes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.VerificationInfo.notes)
}
inline std::string* VerificationInfo::mutable_notes() {
  std::string* _s = _internal_mutable_notes();
  // @@protoc_insertion_point(field_mutable:video_widevine.VerificationInfo.notes)
  return _s;
}
inline const std::string& VerificationInfo::_internal_notes() const {
  return notes_.Get();
}
inline void VerificationInfo::_internal_set_notes(const std::string& value) {
  
  notes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* VerificationInfo::_internal_mutable_notes() {
  
  return notes_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* VerificationInfo::release_notes() {
  // @@protoc_insertion_point(field_release:video_widevine.VerificationInfo.notes)
  return notes_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void VerificationInfo::set_allocated_notes(std::string* notes) {
  if (notes != nullptr) {
    
  } else {
    
  }
  notes_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), notes,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.VerificationInfo.notes)
}

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

// AndroidAttestationKeybox

// bytes ecdsa_private_key = 1;
inline void AndroidAttestationKeybox::clear_ecdsa_private_key() {
  ecdsa_private_key_.ClearToEmpty();
}
inline const std::string& AndroidAttestationKeybox::ecdsa_private_key() const {
  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
  return _internal_ecdsa_private_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AndroidAttestationKeybox::set_ecdsa_private_key(ArgT0&& arg0, ArgT... args) {
 
 ecdsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
}
inline std::string* AndroidAttestationKeybox::mutable_ecdsa_private_key() {
  std::string* _s = _internal_mutable_ecdsa_private_key();
  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
  return _s;
}
inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_private_key() const {
  return ecdsa_private_key_.Get();
}
inline void AndroidAttestationKeybox::_internal_set_ecdsa_private_key(const std::string& value) {
  
  ecdsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AndroidAttestationKeybox::_internal_mutable_ecdsa_private_key() {
  
  return ecdsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AndroidAttestationKeybox::release_ecdsa_private_key() {
  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
  return ecdsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void AndroidAttestationKeybox::set_allocated_ecdsa_private_key(std::string* ecdsa_private_key) {
  if (ecdsa_private_key != nullptr) {
    
  } else {
    
  }
  ecdsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ecdsa_private_key,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
}

// repeated bytes ecdsa_cert = 2;
inline int AndroidAttestationKeybox::_internal_ecdsa_cert_size() const {
  return ecdsa_cert_.size();
}
inline int AndroidAttestationKeybox::ecdsa_cert_size() const {
  return _internal_ecdsa_cert_size();
}
inline void AndroidAttestationKeybox::clear_ecdsa_cert() {
  ecdsa_cert_.Clear();
}
inline std::string* AndroidAttestationKeybox::add_ecdsa_cert() {
  std::string* _s = _internal_add_ecdsa_cert();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
  return _s;
}
inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_cert(int index) const {
  return ecdsa_cert_.Get(index);
}
inline const std::string& AndroidAttestationKeybox::ecdsa_cert(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
  return _internal_ecdsa_cert(index);
}
inline std::string* AndroidAttestationKeybox::mutable_ecdsa_cert(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
  return ecdsa_cert_.Mutable(index);
}
inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const std::string& value) {
  ecdsa_cert_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, std::string&& value) {
  ecdsa_cert_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  ecdsa_cert_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const void* value, size_t size) {
  ecdsa_cert_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline std::string* AndroidAttestationKeybox::_internal_add_ecdsa_cert() {
  return ecdsa_cert_.Add();
}
inline void AndroidAttestationKeybox::add_ecdsa_cert(const std::string& value) {
  ecdsa_cert_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::add_ecdsa_cert(std::string&& value) {
  ecdsa_cert_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::add_ecdsa_cert(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  ecdsa_cert_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline void AndroidAttestationKeybox::add_ecdsa_cert(const void* value, size_t size) {
  ecdsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AndroidAttestationKeybox::ecdsa_cert() const {
  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
  return ecdsa_cert_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AndroidAttestationKeybox::mutable_ecdsa_cert() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
  return &ecdsa_cert_;
}

// bytes rsa_private_key = 3;
inline void AndroidAttestationKeybox::clear_rsa_private_key() {
  rsa_private_key_.ClearToEmpty();
}
inline const std::string& AndroidAttestationKeybox::rsa_private_key() const {
  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_private_key)
  return _internal_rsa_private_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AndroidAttestationKeybox::set_rsa_private_key(ArgT0&& arg0, ArgT... args) {
 
 rsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_private_key)
}
inline std::string* AndroidAttestationKeybox::mutable_rsa_private_key() {
  std::string* _s = _internal_mutable_rsa_private_key();
  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_private_key)
  return _s;
}
inline const std::string& AndroidAttestationKeybox::_internal_rsa_private_key() const {
  return rsa_private_key_.Get();
}
inline void AndroidAttestationKeybox::_internal_set_rsa_private_key(const std::string& value) {
  
  rsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AndroidAttestationKeybox::_internal_mutable_rsa_private_key() {
  
  return rsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AndroidAttestationKeybox::release_rsa_private_key() {
  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.rsa_private_key)
  return rsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void AndroidAttestationKeybox::set_allocated_rsa_private_key(std::string* rsa_private_key) {
  if (rsa_private_key != nullptr) {
    
  } else {
    
  }
  rsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rsa_private_key,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.rsa_private_key)
}

// repeated bytes rsa_cert = 4;
inline int AndroidAttestationKeybox::_internal_rsa_cert_size() const {
  return rsa_cert_.size();
}
inline int AndroidAttestationKeybox::rsa_cert_size() const {
  return _internal_rsa_cert_size();
}
inline void AndroidAttestationKeybox::clear_rsa_cert() {
  rsa_cert_.Clear();
}
inline std::string* AndroidAttestationKeybox::add_rsa_cert() {
  std::string* _s = _internal_add_rsa_cert();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
  return _s;
}
inline const std::string& AndroidAttestationKeybox::_internal_rsa_cert(int index) const {
  return rsa_cert_.Get(index);
}
inline const std::string& AndroidAttestationKeybox::rsa_cert(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_cert)
  return _internal_rsa_cert(index);
}
inline std::string* AndroidAttestationKeybox::mutable_rsa_cert(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
  return rsa_cert_.Mutable(index);
}
inline void AndroidAttestationKeybox::set_rsa_cert(int index, const std::string& value) {
  rsa_cert_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::set_rsa_cert(int index, std::string&& value) {
  rsa_cert_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::set_rsa_cert(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  rsa_cert_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::set_rsa_cert(int index, const void* value, size_t size) {
  rsa_cert_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline std::string* AndroidAttestationKeybox::_internal_add_rsa_cert() {
  return rsa_cert_.Add();
}
inline void AndroidAttestationKeybox::add_rsa_cert(const std::string& value) {
  rsa_cert_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::add_rsa_cert(std::string&& value) {
  rsa_cert_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::add_rsa_cert(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  rsa_cert_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline void AndroidAttestationKeybox::add_rsa_cert(const void* value, size_t size) {
  rsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AndroidAttestationKeybox::rsa_cert() const {
  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
  return rsa_cert_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AndroidAttestationKeybox::mutable_rsa_cert() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
  return &rsa_cert_;
}

// uint32 attestation_keybox_id = 5;
inline void AndroidAttestationKeybox::clear_attestation_keybox_id() {
  attestation_keybox_id_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 AndroidAttestationKeybox::_internal_attestation_keybox_id() const {
  return attestation_keybox_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 AndroidAttestationKeybox::attestation_keybox_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.attestation_keybox_id)
  return _internal_attestation_keybox_id();
}
inline void AndroidAttestationKeybox::_internal_set_attestation_keybox_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  attestation_keybox_id_ = value;
}
inline void AndroidAttestationKeybox::set_attestation_keybox_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_attestation_keybox_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.attestation_keybox_id)
}

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace video_widevine

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::video_widevine::DeviceModel_ModelStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceModel_ModelStatus>() {
  return ::video_widevine::DeviceModel_ModelStatus_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DeviceState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceState>() {
  return ::video_widevine::DeviceState_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DeviceType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceType>() {
  return ::video_widevine::DeviceType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::Platform> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::Platform>() {
  return ::video_widevine::Platform_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::OsOptionalSupport> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::OsOptionalSupport>() {
  return ::video_widevine::OsOptionalSupport_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::HdcpVersion> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::HdcpVersion>() {
  return ::video_widevine::HdcpVersion_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DeviceSecurityLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceSecurityLevel>() {
  return ::video_widevine::DeviceSecurityLevel_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::CertificateKeyType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::CertificateKeyType>() {
  return ::video_widevine::CertificateKeyType_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::RSAKeySize> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::RSAKeySize>() {
  return ::video_widevine::RSAKeySize_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::VulnerabilityLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::VulnerabilityLevel>() {
  return ::video_widevine::VulnerabilityLevel_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::VerificationLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::VerificationLevel>() {
  return ::video_widevine::VerificationLevel_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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