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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_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>
#include "protos/public/hash_algorithm.pb.h"
#include "protos/public/provisioned_device_info.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcertificate_5fstatus_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_5fcertificate_5fstatus_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[5]
    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_5fcertificate_5fstatus_2eproto;
namespace video_widevine {
class DeviceCertificateStatus;
struct DeviceCertificateStatusDefaultTypeInternal;
extern DeviceCertificateStatusDefaultTypeInternal _DeviceCertificateStatus_default_instance_;
class DeviceCertificateStatusList;
struct DeviceCertificateStatusListDefaultTypeInternal;
extern DeviceCertificateStatusListDefaultTypeInternal _DeviceCertificateStatusList_default_instance_;
class DeviceCertificateStatus_RevokedIdentifiers;
struct DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal;
extern DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal _DeviceCertificateStatus_RevokedIdentifiers_default_instance_;
class PublishedDevicesList;
struct PublishedDevicesListDefaultTypeInternal;
extern PublishedDevicesListDefaultTypeInternal _PublishedDevicesList_default_instance_;
class SignedDeviceCertificateStatusList;
struct SignedDeviceCertificateStatusListDefaultTypeInternal;
extern SignedDeviceCertificateStatusListDefaultTypeInternal _SignedDeviceCertificateStatusList_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::DeviceCertificateStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus>(Arena*);
template<> ::video_widevine::DeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatusList>(Arena*);
template<> ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(Arena*);
template<> ::video_widevine::PublishedDevicesList* Arena::CreateMaybeMessage<::video_widevine::PublishedDevicesList>(Arena*);
template<> ::video_widevine::SignedDeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceCertificateStatusList>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum DeviceCertificateStatus_DeprecatedStatus : int {
  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID = 0,
  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED = 1
};
bool DeviceCertificateStatus_DeprecatedStatus_IsValid(int value);
constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
constexpr int DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE = DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_DeprecatedStatus_descriptor();
template<typename T>
inline const std::string& DeviceCertificateStatus_DeprecatedStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceCertificateStatus_DeprecatedStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceCertificateStatus_DeprecatedStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceCertificateStatus_DeprecatedStatus_descriptor(), enum_t_value);
}
inline bool DeviceCertificateStatus_DeprecatedStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_DeprecatedStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_DeprecatedStatus>(
    DeviceCertificateStatus_DeprecatedStatus_descriptor(), name, value);
}
enum DeviceCertificateStatus_Status : int {
  DeviceCertificateStatus_Status_STATUS_UNKNOWN = 0,
  DeviceCertificateStatus_Status_STATUS_IN_TESTING = 10,
  DeviceCertificateStatus_Status_STATUS_RELEASED = 20,
  DeviceCertificateStatus_Status_STATUS_TEST_ONLY = 30,
  DeviceCertificateStatus_Status_STATUS_REVOKED = 40
};
bool DeviceCertificateStatus_Status_IsValid(int value);
constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MIN = DeviceCertificateStatus_Status_STATUS_UNKNOWN;
constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MAX = DeviceCertificateStatus_Status_STATUS_REVOKED;
constexpr int DeviceCertificateStatus_Status_Status_ARRAYSIZE = DeviceCertificateStatus_Status_Status_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_Status_descriptor();
template<typename T>
inline const std::string& DeviceCertificateStatus_Status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceCertificateStatus_Status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceCertificateStatus_Status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceCertificateStatus_Status_descriptor(), enum_t_value);
}
inline bool DeviceCertificateStatus_Status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_Status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_Status>(
    DeviceCertificateStatus_Status_descriptor(), name, value);
}
enum DeviceCertificateStatus_DeviceVulnerabilityLevel : int {
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED = 0,
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE = 1,
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW = 2,
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM = 3,
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH = 4,
  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL = 5
};
bool DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(int value);
constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
constexpr int DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE = DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX + 1;

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

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 DeviceCertificateStatus_RevokedIdentifiers& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeviceCertificateStatus_RevokedIdentifiers* internal_default_instance() {
    return reinterpret_cast<const DeviceCertificateStatus_RevokedIdentifiers*>(
               &_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  DeviceCertificateStatus_RevokedIdentifiers* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceCertificateStatus_RevokedIdentifiers>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceCertificateStatus_RevokedIdentifiers& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceCertificateStatus_RevokedIdentifiers& 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(DeviceCertificateStatus_RevokedIdentifiers* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceCertificateStatus.RevokedIdentifiers";
  }
  protected:
  explicit DeviceCertificateStatus_RevokedIdentifiers(::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 {
    kRevokedCertificateSerialNumbersFieldNumber = 1,
    kRevokedUniqueIdHashesFieldNumber = 2,
  };
  // repeated bytes revoked_certificate_serial_numbers = 1;
  int revoked_certificate_serial_numbers_size() const;
  private:
  int _internal_revoked_certificate_serial_numbers_size() const;
  public:
  void clear_revoked_certificate_serial_numbers();
  const std::string& revoked_certificate_serial_numbers(int index) const;
  std::string* mutable_revoked_certificate_serial_numbers(int index);
  void set_revoked_certificate_serial_numbers(int index, const std::string& value);
  void set_revoked_certificate_serial_numbers(int index, std::string&& value);
  void set_revoked_certificate_serial_numbers(int index, const char* value);
  void set_revoked_certificate_serial_numbers(int index, const void* value, size_t size);
  std::string* add_revoked_certificate_serial_numbers();
  void add_revoked_certificate_serial_numbers(const std::string& value);
  void add_revoked_certificate_serial_numbers(std::string&& value);
  void add_revoked_certificate_serial_numbers(const char* value);
  void add_revoked_certificate_serial_numbers(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_certificate_serial_numbers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_certificate_serial_numbers();
  private:
  const std::string& _internal_revoked_certificate_serial_numbers(int index) const;
  std::string* _internal_add_revoked_certificate_serial_numbers();
  public:

  // repeated bytes revoked_unique_id_hashes = 2;
  int revoked_unique_id_hashes_size() const;
  private:
  int _internal_revoked_unique_id_hashes_size() const;
  public:
  void clear_revoked_unique_id_hashes();
  const std::string& revoked_unique_id_hashes(int index) const;
  std::string* mutable_revoked_unique_id_hashes(int index);
  void set_revoked_unique_id_hashes(int index, const std::string& value);
  void set_revoked_unique_id_hashes(int index, std::string&& value);
  void set_revoked_unique_id_hashes(int index, const char* value);
  void set_revoked_unique_id_hashes(int index, const void* value, size_t size);
  std::string* add_revoked_unique_id_hashes();
  void add_revoked_unique_id_hashes(const std::string& value);
  void add_revoked_unique_id_hashes(std::string&& value);
  void add_revoked_unique_id_hashes(const char* value);
  void add_revoked_unique_id_hashes(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_unique_id_hashes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_unique_id_hashes();
  private:
  const std::string& _internal_revoked_unique_id_hashes(int index) const;
  std::string* _internal_add_revoked_unique_id_hashes();
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatus.RevokedIdentifiers)
 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> revoked_certificate_serial_numbers_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> revoked_unique_id_hashes_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 DeviceCertificateStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeviceCertificateStatus* internal_default_instance() {
    return reinterpret_cast<const DeviceCertificateStatus*>(
               &_DeviceCertificateStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  DeviceCertificateStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceCertificateStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceCertificateStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceCertificateStatus& 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(DeviceCertificateStatus* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceCertificateStatus";
  }
  protected:
  explicit DeviceCertificateStatus(::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 DeviceCertificateStatus_RevokedIdentifiers RevokedIdentifiers;

  typedef DeviceCertificateStatus_DeprecatedStatus DeprecatedStatus;
  static constexpr DeprecatedStatus DEPRECATED_VALID =
    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
  static constexpr DeprecatedStatus DEPRECATED_REVOKED =
    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
  static inline bool DeprecatedStatus_IsValid(int value) {
    return DeviceCertificateStatus_DeprecatedStatus_IsValid(value);
  }
  static constexpr DeprecatedStatus DeprecatedStatus_MIN =
    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN;
  static constexpr DeprecatedStatus DeprecatedStatus_MAX =
    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX;
  static constexpr int DeprecatedStatus_ARRAYSIZE =
    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DeprecatedStatus_descriptor() {
    return DeviceCertificateStatus_DeprecatedStatus_descriptor();
  }
  template<typename T>
  static inline const std::string& DeprecatedStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DeprecatedStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DeprecatedStatus_Name.");
    return DeviceCertificateStatus_DeprecatedStatus_Name(enum_t_value);
  }
  static inline bool DeprecatedStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DeprecatedStatus* value) {
    return DeviceCertificateStatus_DeprecatedStatus_Parse(name, value);
  }

  typedef DeviceCertificateStatus_Status Status;
  static constexpr Status STATUS_UNKNOWN =
    DeviceCertificateStatus_Status_STATUS_UNKNOWN;
  static constexpr Status STATUS_IN_TESTING =
    DeviceCertificateStatus_Status_STATUS_IN_TESTING;
  static constexpr Status STATUS_RELEASED =
    DeviceCertificateStatus_Status_STATUS_RELEASED;
  static constexpr Status STATUS_TEST_ONLY =
    DeviceCertificateStatus_Status_STATUS_TEST_ONLY;
  static constexpr Status STATUS_REVOKED =
    DeviceCertificateStatus_Status_STATUS_REVOKED;
  static inline bool Status_IsValid(int value) {
    return DeviceCertificateStatus_Status_IsValid(value);
  }
  static constexpr Status Status_MIN =
    DeviceCertificateStatus_Status_Status_MIN;
  static constexpr Status Status_MAX =
    DeviceCertificateStatus_Status_Status_MAX;
  static constexpr int Status_ARRAYSIZE =
    DeviceCertificateStatus_Status_Status_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Status_descriptor() {
    return DeviceCertificateStatus_Status_descriptor();
  }
  template<typename T>
  static inline const std::string& Status_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Status>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Status_Name.");
    return DeviceCertificateStatus_Status_Name(enum_t_value);
  }
  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Status* value) {
    return DeviceCertificateStatus_Status_Parse(name, value);
  }

  typedef DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceVulnerabilityLevel;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_NONE =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_LOW =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_MEDIUM =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_HIGH =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH;
  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_CRITICAL =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
  static inline bool DeviceVulnerabilityLevel_IsValid(int value) {
    return DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value);
  }
  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MIN =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN;
  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MAX =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX;
  static constexpr int DeviceVulnerabilityLevel_ARRAYSIZE =
    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DeviceVulnerabilityLevel_descriptor() {
    return DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
  }
  template<typename T>
  static inline const std::string& DeviceVulnerabilityLevel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DeviceVulnerabilityLevel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DeviceVulnerabilityLevel_Name.");
    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Name(enum_t_value);
  }
  static inline bool DeviceVulnerabilityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DeviceVulnerabilityLevel* value) {
    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Parse(name, value);
  }

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

  enum : int {
    kDrmSerialNumberFieldNumber = 1,
    kOemSerialNumberFieldNumber = 5,
    kDeviceInfoFieldNumber = 4,
    kRevokedIdentifiersFieldNumber = 7,
    kDeprecatedStatusFieldNumber = 2,
    kStatusFieldNumber = 6,
    kDeviceVulnerabilityLevelFieldNumber = 8,
  };
  // optional bytes drm_serial_number = 1;
  bool has_drm_serial_number() const;
  private:
  bool _internal_has_drm_serial_number() const;
  public:
  void clear_drm_serial_number();
  const std::string& drm_serial_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_drm_serial_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_drm_serial_number();
  PROTOBUF_MUST_USE_RESULT std::string* release_drm_serial_number();
  void set_allocated_drm_serial_number(std::string* drm_serial_number);
  private:
  const std::string& _internal_drm_serial_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_drm_serial_number(const std::string& value);
  std::string* _internal_mutable_drm_serial_number();
  public:

  // optional bytes oem_serial_number = 5;
  bool has_oem_serial_number() const;
  private:
  bool _internal_has_oem_serial_number() const;
  public:
  void clear_oem_serial_number();
  const std::string& oem_serial_number() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oem_serial_number(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oem_serial_number();
  PROTOBUF_MUST_USE_RESULT std::string* release_oem_serial_number();
  void set_allocated_oem_serial_number(std::string* oem_serial_number);
  private:
  const std::string& _internal_oem_serial_number() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oem_serial_number(const std::string& value);
  std::string* _internal_mutable_oem_serial_number();
  public:

  // optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
  bool has_device_info() const;
  private:
  bool _internal_has_device_info() const;
  public:
  void clear_device_info();
  const ::video_widevine::ProvisionedDeviceInfo& device_info() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisionedDeviceInfo* release_device_info();
  ::video_widevine::ProvisionedDeviceInfo* mutable_device_info();
  void set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info);
  private:
  const ::video_widevine::ProvisionedDeviceInfo& _internal_device_info() const;
  ::video_widevine::ProvisionedDeviceInfo* _internal_mutable_device_info();
  public:
  void unsafe_arena_set_allocated_device_info(
      ::video_widevine::ProvisionedDeviceInfo* device_info);
  ::video_widevine::ProvisionedDeviceInfo* unsafe_arena_release_device_info();

  // optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
  bool has_revoked_identifiers() const;
  private:
  bool _internal_has_revoked_identifiers() const;
  public:
  void clear_revoked_identifiers();
  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& revoked_identifiers() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* release_revoked_identifiers();
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* mutable_revoked_identifiers();
  void set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
  private:
  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& _internal_revoked_identifiers() const;
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _internal_mutable_revoked_identifiers();
  public:
  void unsafe_arena_set_allocated_revoked_identifiers(
      ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* unsafe_arena_release_revoked_identifiers();

  // optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
  bool has_deprecated_status() const;
  private:
  bool _internal_has_deprecated_status() const;
  public:
  void clear_deprecated_status();
  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus deprecated_status() const;
  void set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
  private:
  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus _internal_deprecated_status() const;
  void _internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
  public:

  // optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::video_widevine::DeviceCertificateStatus_Status status() const;
  void set_status(::video_widevine::DeviceCertificateStatus_Status value);
  private:
  ::video_widevine::DeviceCertificateStatus_Status _internal_status() const;
  void _internal_set_status(::video_widevine::DeviceCertificateStatus_Status value);
  public:

  // optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
  bool has_device_vulnerability_level() const;
  private:
  bool _internal_has_device_vulnerability_level() const;
  public:
  void clear_device_vulnerability_level();
  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel device_vulnerability_level() const;
  void set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
  private:
  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel _internal_device_vulnerability_level() const;
  void _internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr drm_serial_number_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oem_serial_number_;
  ::video_widevine::ProvisionedDeviceInfo* device_info_;
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers_;
  int deprecated_status_;
  int status_;
  int device_vulnerability_level_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 DeviceCertificateStatusList& default_instance() {
    return *internal_default_instance();
  }
  static inline const DeviceCertificateStatusList* internal_default_instance() {
    return reinterpret_cast<const DeviceCertificateStatusList*>(
               &_DeviceCertificateStatusList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  DeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceCertificateStatusList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceCertificateStatusList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceCertificateStatusList& 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(DeviceCertificateStatusList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceCertificateStatusList";
  }
  protected:
  explicit DeviceCertificateStatusList(::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 {
    kCertificateStatusFieldNumber = 2,
    kCreationTimeSecondsFieldNumber = 1,
  };
  // repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
  int certificate_status_size() const;
  private:
  int _internal_certificate_status_size() const;
  public:
  void clear_certificate_status();
  ::video_widevine::DeviceCertificateStatus* mutable_certificate_status(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
      mutable_certificate_status();
  private:
  const ::video_widevine::DeviceCertificateStatus& _internal_certificate_status(int index) const;
  ::video_widevine::DeviceCertificateStatus* _internal_add_certificate_status();
  public:
  const ::video_widevine::DeviceCertificateStatus& certificate_status(int index) const;
  ::video_widevine::DeviceCertificateStatus* add_certificate_status();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
      certificate_status() const;

  // optional uint32 creation_time_seconds = 1;
  bool has_creation_time_seconds() const;
  private:
  bool _internal_has_creation_time_seconds() const;
  public:
  void clear_creation_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > certificate_status_;
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 PublishedDevicesList& default_instance() {
    return *internal_default_instance();
  }
  static inline const PublishedDevicesList* internal_default_instance() {
    return reinterpret_cast<const PublishedDevicesList*>(
               &_PublishedDevicesList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  PublishedDevicesList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PublishedDevicesList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PublishedDevicesList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PublishedDevicesList& 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(PublishedDevicesList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.PublishedDevicesList";
  }
  protected:
  explicit PublishedDevicesList(::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 {
    kDeviceCertificateStatusFieldNumber = 2,
    kCreationTimeSecondsFieldNumber = 1,
  };
  // repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
  int device_certificate_status_size() const;
  private:
  int _internal_device_certificate_status_size() const;
  public:
  void clear_device_certificate_status();
  ::video_widevine::DeviceCertificateStatus* mutable_device_certificate_status(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
      mutable_device_certificate_status();
  private:
  const ::video_widevine::DeviceCertificateStatus& _internal_device_certificate_status(int index) const;
  ::video_widevine::DeviceCertificateStatus* _internal_add_device_certificate_status();
  public:
  const ::video_widevine::DeviceCertificateStatus& device_certificate_status(int index) const;
  ::video_widevine::DeviceCertificateStatus* add_device_certificate_status();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
      device_certificate_status() const;

  // optional uint32 creation_time_seconds = 1;
  bool has_creation_time_seconds() const;
  private:
  bool _internal_has_creation_time_seconds() const;
  public:
  void clear_creation_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > device_certificate_status_;
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  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 SignedDeviceCertificateStatusList& default_instance() {
    return *internal_default_instance();
  }
  static inline const SignedDeviceCertificateStatusList* internal_default_instance() {
    return reinterpret_cast<const SignedDeviceCertificateStatusList*>(
               &_SignedDeviceCertificateStatusList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  SignedDeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SignedDeviceCertificateStatusList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SignedDeviceCertificateStatusList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SignedDeviceCertificateStatusList& 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(SignedDeviceCertificateStatusList* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SignedDeviceCertificateStatusList";
  }
  protected:
  explicit SignedDeviceCertificateStatusList(::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 {
    kCertificateStatusListFieldNumber = 1,
    kSignatureFieldNumber = 2,
    kHashAlgorithmFieldNumber = 3,
  };
  // optional bytes certificate_status_list = 1;
  bool has_certificate_status_list() const;
  private:
  bool _internal_has_certificate_status_list() const;
  public:
  void clear_certificate_status_list();
  const std::string& certificate_status_list() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_certificate_status_list(ArgT0&& arg0, ArgT... args);
  std::string* mutable_certificate_status_list();
  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_status_list();
  void set_allocated_certificate_status_list(std::string* certificate_status_list);
  private:
  const std::string& _internal_certificate_status_list() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_status_list(const std::string& value);
  std::string* _internal_mutable_certificate_status_list();
  public:

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

  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
  bool has_hash_algorithm() const;
  private:
  bool _internal_has_hash_algorithm() const;
  public:
  void clear_hash_algorithm();
  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
  private:
  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_status_list_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  int hash_algorithm_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// ===================================================================


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

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

// repeated bytes revoked_certificate_serial_numbers = 1;
inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers_size() const {
  return revoked_certificate_serial_numbers_.size();
}
inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers_size() const {
  return _internal_revoked_certificate_serial_numbers_size();
}
inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_certificate_serial_numbers() {
  revoked_certificate_serial_numbers_.Clear();
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers() {
  std::string* _s = _internal_add_revoked_certificate_serial_numbers();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
  return _s;
}
inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers(int index) const {
  return revoked_certificate_serial_numbers_.Get(index);
}
inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
  return _internal_revoked_certificate_serial_numbers(index);
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
  return revoked_certificate_serial_numbers_.Mutable(index);
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const std::string& value) {
  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, std::string&& value) {
  revoked_certificate_serial_numbers_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const void* value, size_t size) {
  revoked_certificate_serial_numbers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_certificate_serial_numbers() {
  return revoked_certificate_serial_numbers_.Add();
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const std::string& value) {
  revoked_certificate_serial_numbers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(std::string&& value) {
  revoked_certificate_serial_numbers_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  revoked_certificate_serial_numbers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const void* value, size_t size) {
  revoked_certificate_serial_numbers_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
  return revoked_certificate_serial_numbers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
  return &revoked_certificate_serial_numbers_;
}

// repeated bytes revoked_unique_id_hashes = 2;
inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes_size() const {
  return revoked_unique_id_hashes_.size();
}
inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes_size() const {
  return _internal_revoked_unique_id_hashes_size();
}
inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_unique_id_hashes() {
  revoked_unique_id_hashes_.Clear();
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes() {
  std::string* _s = _internal_add_revoked_unique_id_hashes();
  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
  return _s;
}
inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes(int index) const {
  return revoked_unique_id_hashes_.Get(index);
}
inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
  return _internal_revoked_unique_id_hashes(index);
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
  return revoked_unique_id_hashes_.Mutable(index);
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const std::string& value) {
  revoked_unique_id_hashes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, std::string&& value) {
  revoked_unique_id_hashes_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  revoked_unique_id_hashes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const void* value, size_t size) {
  revoked_unique_id_hashes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_unique_id_hashes() {
  return revoked_unique_id_hashes_.Add();
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const std::string& value) {
  revoked_unique_id_hashes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(std::string&& value) {
  revoked_unique_id_hashes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  revoked_unique_id_hashes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const void* value, size_t size) {
  revoked_unique_id_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
  return revoked_unique_id_hashes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
  return &revoked_unique_id_hashes_;
}

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

// DeviceCertificateStatus

// optional bytes drm_serial_number = 1;
inline bool DeviceCertificateStatus::_internal_has_drm_serial_number() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceCertificateStatus::has_drm_serial_number() const {
  return _internal_has_drm_serial_number();
}
inline void DeviceCertificateStatus::clear_drm_serial_number() {
  drm_serial_number_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceCertificateStatus::drm_serial_number() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.drm_serial_number)
  return _internal_drm_serial_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceCertificateStatus::set_drm_serial_number(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 drm_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.drm_serial_number)
}
inline std::string* DeviceCertificateStatus::mutable_drm_serial_number() {
  std::string* _s = _internal_mutable_drm_serial_number();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.drm_serial_number)
  return _s;
}
inline const std::string& DeviceCertificateStatus::_internal_drm_serial_number() const {
  return drm_serial_number_.Get();
}
inline void DeviceCertificateStatus::_internal_set_drm_serial_number(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  drm_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceCertificateStatus::_internal_mutable_drm_serial_number() {
  _has_bits_[0] |= 0x00000001u;
  return drm_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceCertificateStatus::release_drm_serial_number() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.drm_serial_number)
  if (!_internal_has_drm_serial_number()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return drm_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceCertificateStatus::set_allocated_drm_serial_number(std::string* drm_serial_number) {
  if (drm_serial_number != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  drm_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), drm_serial_number,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.drm_serial_number)
}

// optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
inline bool DeviceCertificateStatus::_internal_has_deprecated_status() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DeviceCertificateStatus::has_deprecated_status() const {
  return _internal_has_deprecated_status();
}
inline void DeviceCertificateStatus::clear_deprecated_status() {
  deprecated_status_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::_internal_deprecated_status() const {
  return static_cast< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus >(deprecated_status_);
}
inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::deprecated_status() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.deprecated_status)
  return _internal_deprecated_status();
}
inline void DeviceCertificateStatus::_internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
  assert(::video_widevine::DeviceCertificateStatus_DeprecatedStatus_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  deprecated_status_ = value;
}
inline void DeviceCertificateStatus::set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
  _internal_set_deprecated_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.deprecated_status)
}

// optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
inline bool DeviceCertificateStatus::_internal_has_device_info() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || device_info_ != nullptr);
  return value;
}
inline bool DeviceCertificateStatus::has_device_info() const {
  return _internal_has_device_info();
}
inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::_internal_device_info() const {
  const ::video_widevine::ProvisionedDeviceInfo* p = device_info_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisionedDeviceInfo&>(
      ::video_widevine::_ProvisionedDeviceInfo_default_instance_);
}
inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::device_info() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_info)
  return _internal_device_info();
}
inline void DeviceCertificateStatus::unsafe_arena_set_allocated_device_info(
    ::video_widevine::ProvisionedDeviceInfo* device_info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
  }
  device_info_ = device_info;
  if (device_info) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
}
inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::release_device_info() {
  _has_bits_[0] &= ~0x00000004u;
  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
  device_info_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::unsafe_arena_release_device_info() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.device_info)
  _has_bits_[0] &= ~0x00000004u;
  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
  device_info_ = nullptr;
  return temp;
}
inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::_internal_mutable_device_info() {
  _has_bits_[0] |= 0x00000004u;
  if (device_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::ProvisionedDeviceInfo>(GetArenaForAllocation());
    device_info_ = p;
  }
  return device_info_;
}
inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::mutable_device_info() {
  ::video_widevine::ProvisionedDeviceInfo* _msg = _internal_mutable_device_info();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.device_info)
  return _msg;
}
inline void DeviceCertificateStatus::set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
  }
  if (device_info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info));
    if (message_arena != submessage_arena) {
      device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_info, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  device_info_ = device_info;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
}

// optional bytes oem_serial_number = 5;
inline bool DeviceCertificateStatus::_internal_has_oem_serial_number() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceCertificateStatus::has_oem_serial_number() const {
  return _internal_has_oem_serial_number();
}
inline void DeviceCertificateStatus::clear_oem_serial_number() {
  oem_serial_number_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DeviceCertificateStatus::oem_serial_number() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.oem_serial_number)
  return _internal_oem_serial_number();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceCertificateStatus::set_oem_serial_number(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 oem_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.oem_serial_number)
}
inline std::string* DeviceCertificateStatus::mutable_oem_serial_number() {
  std::string* _s = _internal_mutable_oem_serial_number();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.oem_serial_number)
  return _s;
}
inline const std::string& DeviceCertificateStatus::_internal_oem_serial_number() const {
  return oem_serial_number_.Get();
}
inline void DeviceCertificateStatus::_internal_set_oem_serial_number(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  oem_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceCertificateStatus::_internal_mutable_oem_serial_number() {
  _has_bits_[0] |= 0x00000002u;
  return oem_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceCertificateStatus::release_oem_serial_number() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.oem_serial_number)
  if (!_internal_has_oem_serial_number()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return oem_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void DeviceCertificateStatus::set_allocated_oem_serial_number(std::string* oem_serial_number) {
  if (oem_serial_number != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  oem_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oem_serial_number,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.oem_serial_number)
}

// optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
inline bool DeviceCertificateStatus::_internal_has_status() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool DeviceCertificateStatus::has_status() const {
  return _internal_has_status();
}
inline void DeviceCertificateStatus::clear_status() {
  status_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::_internal_status() const {
  return static_cast< ::video_widevine::DeviceCertificateStatus_Status >(status_);
}
inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::status() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.status)
  return _internal_status();
}
inline void DeviceCertificateStatus::_internal_set_status(::video_widevine::DeviceCertificateStatus_Status value) {
  assert(::video_widevine::DeviceCertificateStatus_Status_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  status_ = value;
}
inline void DeviceCertificateStatus::set_status(::video_widevine::DeviceCertificateStatus_Status value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.status)
}

// optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
inline bool DeviceCertificateStatus::_internal_has_revoked_identifiers() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || revoked_identifiers_ != nullptr);
  return value;
}
inline bool DeviceCertificateStatus::has_revoked_identifiers() const {
  return _internal_has_revoked_identifiers();
}
inline void DeviceCertificateStatus::clear_revoked_identifiers() {
  if (revoked_identifiers_ != nullptr) revoked_identifiers_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::_internal_revoked_identifiers() const {
  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* p = revoked_identifiers_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers&>(
      ::video_widevine::_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
}
inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::revoked_identifiers() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.revoked_identifiers)
  return _internal_revoked_identifiers();
}
inline void DeviceCertificateStatus::unsafe_arena_set_allocated_revoked_identifiers(
    ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revoked_identifiers_);
  }
  revoked_identifiers_ = revoked_identifiers;
  if (revoked_identifiers) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
}
inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::release_revoked_identifiers() {
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
  revoked_identifiers_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::unsafe_arena_release_revoked_identifiers() {
  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.revoked_identifiers)
  _has_bits_[0] &= ~0x00000008u;
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
  revoked_identifiers_ = nullptr;
  return temp;
}
inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::_internal_mutable_revoked_identifiers() {
  _has_bits_[0] |= 0x00000008u;
  if (revoked_identifiers_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(GetArenaForAllocation());
    revoked_identifiers_ = p;
  }
  return revoked_identifiers_;
}
inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::mutable_revoked_identifiers() {
  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _msg = _internal_mutable_revoked_identifiers();
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.revoked_identifiers)
  return _msg;
}
inline void DeviceCertificateStatus::set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete revoked_identifiers_;
  }
  if (revoked_identifiers) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>::GetOwningArena(revoked_identifiers);
    if (message_arena != submessage_arena) {
      revoked_identifiers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revoked_identifiers, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  revoked_identifiers_ = revoked_identifiers;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
}

// optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
inline bool DeviceCertificateStatus::_internal_has_device_vulnerability_level() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool DeviceCertificateStatus::has_device_vulnerability_level() const {
  return _internal_has_device_vulnerability_level();
}
inline void DeviceCertificateStatus::clear_device_vulnerability_level() {
  device_vulnerability_level_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::_internal_device_vulnerability_level() const {
  return static_cast< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel >(device_vulnerability_level_);
}
inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::device_vulnerability_level() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
  return _internal_device_vulnerability_level();
}
inline void DeviceCertificateStatus::_internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
  assert(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value));
  _has_bits_[0] |= 0x00000040u;
  device_vulnerability_level_ = value;
}
inline void DeviceCertificateStatus::set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
  _internal_set_device_vulnerability_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
}

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

// DeviceCertificateStatusList

// optional uint32 creation_time_seconds = 1;
inline bool DeviceCertificateStatusList::_internal_has_creation_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceCertificateStatusList::has_creation_time_seconds() const {
  return _internal_has_creation_time_seconds();
}
inline void DeviceCertificateStatusList::clear_creation_time_seconds() {
  creation_time_seconds_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::_internal_creation_time_seconds() const {
  return creation_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::creation_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
  return _internal_creation_time_seconds();
}
inline void DeviceCertificateStatusList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  creation_time_seconds_ = value;
}
inline void DeviceCertificateStatusList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_creation_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
}

// repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
inline int DeviceCertificateStatusList::_internal_certificate_status_size() const {
  return certificate_status_.size();
}
inline int DeviceCertificateStatusList::certificate_status_size() const {
  return _internal_certificate_status_size();
}
inline void DeviceCertificateStatusList::clear_certificate_status() {
  certificate_status_.Clear();
}
inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::mutable_certificate_status(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusList.certificate_status)
  return certificate_status_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
DeviceCertificateStatusList::mutable_certificate_status() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatusList.certificate_status)
  return &certificate_status_;
}
inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::_internal_certificate_status(int index) const {
  return certificate_status_.Get(index);
}
inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::certificate_status(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.certificate_status)
  return _internal_certificate_status(index);
}
inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::_internal_add_certificate_status() {
  return certificate_status_.Add();
}
inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::add_certificate_status() {
  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_certificate_status();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatusList.certificate_status)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
DeviceCertificateStatusList::certificate_status() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatusList.certificate_status)
  return certificate_status_;
}

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

// PublishedDevicesList

// optional uint32 creation_time_seconds = 1;
inline bool PublishedDevicesList::_internal_has_creation_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PublishedDevicesList::has_creation_time_seconds() const {
  return _internal_has_creation_time_seconds();
}
inline void PublishedDevicesList::clear_creation_time_seconds() {
  creation_time_seconds_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::_internal_creation_time_seconds() const {
  return creation_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::creation_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.creation_time_seconds)
  return _internal_creation_time_seconds();
}
inline void PublishedDevicesList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  creation_time_seconds_ = value;
}
inline void PublishedDevicesList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_creation_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.PublishedDevicesList.creation_time_seconds)
}

// repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
inline int PublishedDevicesList::_internal_device_certificate_status_size() const {
  return device_certificate_status_.size();
}
inline int PublishedDevicesList::device_certificate_status_size() const {
  return _internal_device_certificate_status_size();
}
inline void PublishedDevicesList::clear_device_certificate_status() {
  device_certificate_status_.Clear();
}
inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::mutable_device_certificate_status(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.PublishedDevicesList.device_certificate_status)
  return device_certificate_status_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
PublishedDevicesList::mutable_device_certificate_status() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.PublishedDevicesList.device_certificate_status)
  return &device_certificate_status_;
}
inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::_internal_device_certificate_status(int index) const {
  return device_certificate_status_.Get(index);
}
inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::device_certificate_status(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.device_certificate_status)
  return _internal_device_certificate_status(index);
}
inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::_internal_add_device_certificate_status() {
  return device_certificate_status_.Add();
}
inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::add_device_certificate_status() {
  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_device_certificate_status();
  // @@protoc_insertion_point(field_add:video_widevine.PublishedDevicesList.device_certificate_status)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
PublishedDevicesList::device_certificate_status() const {
  // @@protoc_insertion_point(field_list:video_widevine.PublishedDevicesList.device_certificate_status)
  return device_certificate_status_;
}

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

// SignedDeviceCertificateStatusList

// optional bytes certificate_status_list = 1;
inline bool SignedDeviceCertificateStatusList::_internal_has_certificate_status_list() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SignedDeviceCertificateStatusList::has_certificate_status_list() const {
  return _internal_has_certificate_status_list();
}
inline void SignedDeviceCertificateStatusList::clear_certificate_status_list() {
  certificate_status_list_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SignedDeviceCertificateStatusList::certificate_status_list() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
  return _internal_certificate_status_list();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedDeviceCertificateStatusList::set_certificate_status_list(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 certificate_status_list_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
}
inline std::string* SignedDeviceCertificateStatusList::mutable_certificate_status_list() {
  std::string* _s = _internal_mutable_certificate_status_list();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
  return _s;
}
inline const std::string& SignedDeviceCertificateStatusList::_internal_certificate_status_list() const {
  return certificate_status_list_.Get();
}
inline void SignedDeviceCertificateStatusList::_internal_set_certificate_status_list(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  certificate_status_list_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_certificate_status_list() {
  _has_bits_[0] |= 0x00000001u;
  return certificate_status_list_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedDeviceCertificateStatusList::release_certificate_status_list() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
  if (!_internal_has_certificate_status_list()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return certificate_status_list_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedDeviceCertificateStatusList::set_allocated_certificate_status_list(std::string* certificate_status_list) {
  if (certificate_status_list != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  certificate_status_list_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_status_list,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
}

// optional bytes signature = 2;
inline bool SignedDeviceCertificateStatusList::_internal_has_signature() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SignedDeviceCertificateStatusList::has_signature() const {
  return _internal_has_signature();
}
inline void SignedDeviceCertificateStatusList::clear_signature() {
  signature_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SignedDeviceCertificateStatusList::signature() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedDeviceCertificateStatusList::set_signature(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.signature)
}
inline std::string* SignedDeviceCertificateStatusList::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.signature)
  return _s;
}
inline const std::string& SignedDeviceCertificateStatusList::_internal_signature() const {
  return signature_.Get();
}
inline void SignedDeviceCertificateStatusList::_internal_set_signature(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_signature() {
  _has_bits_[0] |= 0x00000002u;
  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SignedDeviceCertificateStatusList::release_signature() {
  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void SignedDeviceCertificateStatusList::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.signature)
}

// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
inline bool SignedDeviceCertificateStatusList::_internal_has_hash_algorithm() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SignedDeviceCertificateStatusList::has_hash_algorithm() const {
  return _internal_has_hash_algorithm();
}
inline void SignedDeviceCertificateStatusList::clear_hash_algorithm() {
  hash_algorithm_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::_internal_hash_algorithm() const {
  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
}
inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::hash_algorithm() const {
  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
  return _internal_hash_algorithm();
}
inline void SignedDeviceCertificateStatusList::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  hash_algorithm_ = value;
}
inline void SignedDeviceCertificateStatusList::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
  _internal_set_hash_algorithm(value);
  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
}

#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::DeviceCertificateStatus_DeprecatedStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus>() {
  return ::video_widevine::DeviceCertificateStatus_DeprecatedStatus_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_Status>() {
  return ::video_widevine::DeviceCertificateStatus_Status_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel>() {
  return ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_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_5fcertificate_5fstatus_2eproto