// 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[7]
    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 ImpactAnalysis;
struct ImpactAnalysisDefaultTypeInternal;
extern ImpactAnalysisDefaultTypeInternal _ImpactAnalysis_default_instance_;
class ImpactAnalysis_ImpactAnalysisMetrics;
struct ImpactAnalysis_ImpactAnalysisMetricsDefaultTypeInternal;
extern ImpactAnalysis_ImpactAnalysisMetricsDefaultTypeInternal _ImpactAnalysis_ImpactAnalysisMetrics_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::ImpactAnalysis* Arena::CreateMaybeMessage<::video_widevine::ImpactAnalysis>(Arena*);
template<> ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* Arena::CreateMaybeMessage<::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics>(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 ImpactAnalysis_DeviceStatusOperation : int {
  ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_OPERATION_UNSPECIFIED = 0,
  ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_UPDATE = 1,
  ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_REVOKE = 2
};
bool ImpactAnalysis_DeviceStatusOperation_IsValid(int value);
constexpr ImpactAnalysis_DeviceStatusOperation ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_MIN = ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_OPERATION_UNSPECIFIED;
constexpr ImpactAnalysis_DeviceStatusOperation ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_MAX = ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_REVOKE;
constexpr int ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_ARRAYSIZE = ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImpactAnalysis_DeviceStatusOperation_descriptor();
template<typename T>
inline const std::string& ImpactAnalysis_DeviceStatusOperation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ImpactAnalysis_DeviceStatusOperation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ImpactAnalysis_DeviceStatusOperation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ImpactAnalysis_DeviceStatusOperation_descriptor(), enum_t_value);
}
inline bool ImpactAnalysis_DeviceStatusOperation_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImpactAnalysis_DeviceStatusOperation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImpactAnalysis_DeviceStatusOperation>(
    ImpactAnalysis_DeviceStatusOperation_descriptor(), name, value);
}
enum ImpactAnalysis_DeviceStatusImpact : int {
  ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_UNSPECIFIED = 0,
  ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_NONE = 1,
  ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_LOW = 2,
  ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_MEDIUM = 3,
  ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_HIGH = 4
};
bool ImpactAnalysis_DeviceStatusImpact_IsValid(int value);
constexpr ImpactAnalysis_DeviceStatusImpact ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_MIN = ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_UNSPECIFIED;
constexpr ImpactAnalysis_DeviceStatusImpact ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_MAX = ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_HIGH;
constexpr int ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_ARRAYSIZE = ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImpactAnalysis_DeviceStatusImpact_descriptor();
template<typename T>
inline const std::string& ImpactAnalysis_DeviceStatusImpact_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ImpactAnalysis_DeviceStatusImpact>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ImpactAnalysis_DeviceStatusImpact_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ImpactAnalysis_DeviceStatusImpact_descriptor(), enum_t_value);
}
inline bool ImpactAnalysis_DeviceStatusImpact_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImpactAnalysis_DeviceStatusImpact* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImpactAnalysis_DeviceStatusImpact>(
    ImpactAnalysis_DeviceStatusImpact_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);
  }

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

  enum : int {
    kDrmSerialNumberFieldNumber = 1,
    kOemSerialNumberFieldNumber = 5,
    kDeviceInfoFieldNumber = 4,
    kRevokedIdentifiersFieldNumber = 7,
    kDeprecatedStatusFieldNumber = 2,
    kStatusFieldNumber = 6,
  };
  // 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:

  // @@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_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  ImpactAnalysis_ImpactAnalysisMetrics* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ImpactAnalysis_ImpactAnalysisMetrics>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ImpactAnalysis_ImpactAnalysisMetrics& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ImpactAnalysis_ImpactAnalysisMetrics& 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(ImpactAnalysis_ImpactAnalysisMetrics* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ImpactAnalysis.ImpactAnalysisMetrics";
  }
  protected:
  explicit ImpactAnalysis_ImpactAnalysisMetrics(::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 {
    kImpactValueFieldNumber = 1,
    kRequestNumberFieldNumber = 2,
    kRequestDurationDaysFieldNumber = 3,
  };
  // optional float impact_value = 1;
  bool has_impact_value() const;
  private:
  bool _internal_has_impact_value() const;
  public:
  void clear_impact_value();
  float impact_value() const;
  void set_impact_value(float value);
  private:
  float _internal_impact_value() const;
  void _internal_set_impact_value(float value);
  public:

  // optional uint32 request_number = 2;
  bool has_request_number() const;
  private:
  bool _internal_has_request_number() const;
  public:
  void clear_request_number();
  ::PROTOBUF_NAMESPACE_ID::uint32 request_number() const;
  void set_request_number(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_request_number() const;
  void _internal_set_request_number(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional uint32 request_duration_days = 3;
  bool has_request_duration_days() const;
  private:
  bool _internal_has_request_duration_days() const;
  public:
  void clear_request_duration_days();
  ::PROTOBUF_NAMESPACE_ID::uint32 request_duration_days() const;
  void set_request_duration_days(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_request_duration_days() const;
  void _internal_set_request_duration_days(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics)
 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_;
  float impact_value_;
  ::PROTOBUF_NAMESPACE_ID::uint32 request_number_;
  ::PROTOBUF_NAMESPACE_ID::uint32 request_duration_days_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  typedef ImpactAnalysis_DeviceStatusOperation DeviceStatusOperation;
  static constexpr DeviceStatusOperation DEVICE_STATUS_OPERATION_UNSPECIFIED =
    ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_OPERATION_UNSPECIFIED;
  static constexpr DeviceStatusOperation DEVICE_STATUS_UPDATE =
    ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_UPDATE;
  static constexpr DeviceStatusOperation DEVICE_STATUS_REVOKE =
    ImpactAnalysis_DeviceStatusOperation_DEVICE_STATUS_REVOKE;
  static inline bool DeviceStatusOperation_IsValid(int value) {
    return ImpactAnalysis_DeviceStatusOperation_IsValid(value);
  }
  static constexpr DeviceStatusOperation DeviceStatusOperation_MIN =
    ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_MIN;
  static constexpr DeviceStatusOperation DeviceStatusOperation_MAX =
    ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_MAX;
  static constexpr int DeviceStatusOperation_ARRAYSIZE =
    ImpactAnalysis_DeviceStatusOperation_DeviceStatusOperation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DeviceStatusOperation_descriptor() {
    return ImpactAnalysis_DeviceStatusOperation_descriptor();
  }
  template<typename T>
  static inline const std::string& DeviceStatusOperation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DeviceStatusOperation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DeviceStatusOperation_Name.");
    return ImpactAnalysis_DeviceStatusOperation_Name(enum_t_value);
  }
  static inline bool DeviceStatusOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DeviceStatusOperation* value) {
    return ImpactAnalysis_DeviceStatusOperation_Parse(name, value);
  }

  typedef ImpactAnalysis_DeviceStatusImpact DeviceStatusImpact;
  static constexpr DeviceStatusImpact DEVICE_STATUS_IMPACT_UNSPECIFIED =
    ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_UNSPECIFIED;
  static constexpr DeviceStatusImpact DEVICE_STATUS_IMPACT_NONE =
    ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_NONE;
  static constexpr DeviceStatusImpact DEVICE_STATUS_IMPACT_LOW =
    ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_LOW;
  static constexpr DeviceStatusImpact DEVICE_STATUS_IMPACT_MEDIUM =
    ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_MEDIUM;
  static constexpr DeviceStatusImpact DEVICE_STATUS_IMPACT_HIGH =
    ImpactAnalysis_DeviceStatusImpact_DEVICE_STATUS_IMPACT_HIGH;
  static inline bool DeviceStatusImpact_IsValid(int value) {
    return ImpactAnalysis_DeviceStatusImpact_IsValid(value);
  }
  static constexpr DeviceStatusImpact DeviceStatusImpact_MIN =
    ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_MIN;
  static constexpr DeviceStatusImpact DeviceStatusImpact_MAX =
    ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_MAX;
  static constexpr int DeviceStatusImpact_ARRAYSIZE =
    ImpactAnalysis_DeviceStatusImpact_DeviceStatusImpact_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DeviceStatusImpact_descriptor() {
    return ImpactAnalysis_DeviceStatusImpact_descriptor();
  }
  template<typename T>
  static inline const std::string& DeviceStatusImpact_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DeviceStatusImpact>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DeviceStatusImpact_Name.");
    return ImpactAnalysis_DeviceStatusImpact_Name(enum_t_value);
  }
  static inline bool DeviceStatusImpact_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DeviceStatusImpact* value) {
    return ImpactAnalysis_DeviceStatusImpact_Parse(name, value);
  }

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

  enum : int {
    kImpactAnalysisMetricsFieldNumber = 5,
    kSystemIdFieldNumber = 1,
    kImpactFieldNumber = 2,
    kOperationFieldNumber = 3,
    kOperationTimeSecondsFieldNumber = 4,
  };
  // optional .video_widevine.ImpactAnalysis.ImpactAnalysisMetrics impact_analysis_metrics = 5;
  bool has_impact_analysis_metrics() const;
  private:
  bool _internal_has_impact_analysis_metrics() const;
  public:
  void clear_impact_analysis_metrics();
  const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics& impact_analysis_metrics() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* release_impact_analysis_metrics();
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* mutable_impact_analysis_metrics();
  void set_allocated_impact_analysis_metrics(::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* impact_analysis_metrics);
  private:
  const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics& _internal_impact_analysis_metrics() const;
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* _internal_mutable_impact_analysis_metrics();
  public:
  void unsafe_arena_set_allocated_impact_analysis_metrics(
      ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* impact_analysis_metrics);
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* unsafe_arena_release_impact_analysis_metrics();

  // optional uint32 system_id = 1;
  bool has_system_id() const;
  private:
  bool _internal_has_system_id() const;
  public:
  void clear_system_id();
  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.ImpactAnalysis.DeviceStatusImpact impact = 2;
  bool has_impact() const;
  private:
  bool _internal_has_impact() const;
  public:
  void clear_impact();
  ::video_widevine::ImpactAnalysis_DeviceStatusImpact impact() const;
  void set_impact(::video_widevine::ImpactAnalysis_DeviceStatusImpact value);
  private:
  ::video_widevine::ImpactAnalysis_DeviceStatusImpact _internal_impact() const;
  void _internal_set_impact(::video_widevine::ImpactAnalysis_DeviceStatusImpact value);
  public:

  // optional .video_widevine.ImpactAnalysis.DeviceStatusOperation operation = 3;
  bool has_operation() const;
  private:
  bool _internal_has_operation() const;
  public:
  void clear_operation();
  ::video_widevine::ImpactAnalysis_DeviceStatusOperation operation() const;
  void set_operation(::video_widevine::ImpactAnalysis_DeviceStatusOperation value);
  private:
  ::video_widevine::ImpactAnalysis_DeviceStatusOperation _internal_operation() const;
  void _internal_set_operation(::video_widevine::ImpactAnalysis_DeviceStatusOperation value);
  public:

  // optional uint32 operation_time_seconds = 4;
  bool has_operation_time_seconds() const;
  private:
  bool _internal_has_operation_time_seconds() const;
  public:
  void clear_operation_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::uint32 operation_time_seconds() const;
  void set_operation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_operation_time_seconds() const;
  void _internal_set_operation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ImpactAnalysis)
 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_;
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* impact_analysis_metrics_;
  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
  int impact_;
  int operation_;
  ::PROTOBUF_NAMESPACE_ID::uint32 operation_time_seconds_;
  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 =
    4;

  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,
    kImpactAnalysisFieldNumber = 3,
    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;

  // repeated .video_widevine.ImpactAnalysis impact_analysis = 3;
  int impact_analysis_size() const;
  private:
  int _internal_impact_analysis_size() const;
  public:
  void clear_impact_analysis();
  ::video_widevine::ImpactAnalysis* mutable_impact_analysis(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >*
      mutable_impact_analysis();
  private:
  const ::video_widevine::ImpactAnalysis& _internal_impact_analysis(int index) const;
  ::video_widevine::ImpactAnalysis* _internal_add_impact_analysis();
  public:
  const ::video_widevine::ImpactAnalysis& impact_analysis(int index) const;
  ::video_widevine::ImpactAnalysis* add_impact_analysis();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >&
      impact_analysis() 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::RepeatedPtrField< ::video_widevine::ImpactAnalysis > impact_analysis_;
  ::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 =
    5;

  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,
    kImpactAnalysisFieldNumber = 3,
    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;

  // repeated .video_widevine.ImpactAnalysis impact_analysis = 3;
  int impact_analysis_size() const;
  private:
  int _internal_impact_analysis_size() const;
  public:
  void clear_impact_analysis();
  ::video_widevine::ImpactAnalysis* mutable_impact_analysis(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >*
      mutable_impact_analysis();
  private:
  const ::video_widevine::ImpactAnalysis& _internal_impact_analysis(int index) const;
  ::video_widevine::ImpactAnalysis* _internal_add_impact_analysis();
  public:
  const ::video_widevine::ImpactAnalysis& impact_analysis(int index) const;
  ::video_widevine::ImpactAnalysis* add_impact_analysis();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >&
      impact_analysis() 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::RepeatedPtrField< ::video_widevine::ImpactAnalysis > impact_analysis_;
  ::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 =
    6;

  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)
}

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

// ImpactAnalysis_ImpactAnalysisMetrics

// optional float impact_value = 1;
inline bool ImpactAnalysis_ImpactAnalysisMetrics::_internal_has_impact_value() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ImpactAnalysis_ImpactAnalysisMetrics::has_impact_value() const {
  return _internal_has_impact_value();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::clear_impact_value() {
  impact_value_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline float ImpactAnalysis_ImpactAnalysisMetrics::_internal_impact_value() const {
  return impact_value_;
}
inline float ImpactAnalysis_ImpactAnalysisMetrics::impact_value() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.impact_value)
  return _internal_impact_value();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::_internal_set_impact_value(float value) {
  _has_bits_[0] |= 0x00000001u;
  impact_value_ = value;
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::set_impact_value(float value) {
  _internal_set_impact_value(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.impact_value)
}

// optional uint32 request_number = 2;
inline bool ImpactAnalysis_ImpactAnalysisMetrics::_internal_has_request_number() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ImpactAnalysis_ImpactAnalysisMetrics::has_request_number() const {
  return _internal_has_request_number();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::clear_request_number() {
  request_number_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis_ImpactAnalysisMetrics::_internal_request_number() const {
  return request_number_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis_ImpactAnalysisMetrics::request_number() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.request_number)
  return _internal_request_number();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::_internal_set_request_number(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  request_number_ = value;
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::set_request_number(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_request_number(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.request_number)
}

// optional uint32 request_duration_days = 3;
inline bool ImpactAnalysis_ImpactAnalysisMetrics::_internal_has_request_duration_days() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ImpactAnalysis_ImpactAnalysisMetrics::has_request_duration_days() const {
  return _internal_has_request_duration_days();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::clear_request_duration_days() {
  request_duration_days_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis_ImpactAnalysisMetrics::_internal_request_duration_days() const {
  return request_duration_days_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis_ImpactAnalysisMetrics::request_duration_days() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.request_duration_days)
  return _internal_request_duration_days();
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::_internal_set_request_duration_days(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  request_duration_days_ = value;
}
inline void ImpactAnalysis_ImpactAnalysisMetrics::set_request_duration_days(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_request_duration_days(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.ImpactAnalysisMetrics.request_duration_days)
}

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

// ImpactAnalysis

// optional uint32 system_id = 1;
inline bool ImpactAnalysis::_internal_has_system_id() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ImpactAnalysis::has_system_id() const {
  return _internal_has_system_id();
}
inline void ImpactAnalysis::clear_system_id() {
  system_id_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis::_internal_system_id() const {
  return system_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis::system_id() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.system_id)
  return _internal_system_id();
}
inline void ImpactAnalysis::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  system_id_ = value;
}
inline void ImpactAnalysis::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_system_id(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.system_id)
}

// optional .video_widevine.ImpactAnalysis.DeviceStatusImpact impact = 2;
inline bool ImpactAnalysis::_internal_has_impact() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ImpactAnalysis::has_impact() const {
  return _internal_has_impact();
}
inline void ImpactAnalysis::clear_impact() {
  impact_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::ImpactAnalysis_DeviceStatusImpact ImpactAnalysis::_internal_impact() const {
  return static_cast< ::video_widevine::ImpactAnalysis_DeviceStatusImpact >(impact_);
}
inline ::video_widevine::ImpactAnalysis_DeviceStatusImpact ImpactAnalysis::impact() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.impact)
  return _internal_impact();
}
inline void ImpactAnalysis::_internal_set_impact(::video_widevine::ImpactAnalysis_DeviceStatusImpact value) {
  assert(::video_widevine::ImpactAnalysis_DeviceStatusImpact_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  impact_ = value;
}
inline void ImpactAnalysis::set_impact(::video_widevine::ImpactAnalysis_DeviceStatusImpact value) {
  _internal_set_impact(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.impact)
}

// optional .video_widevine.ImpactAnalysis.DeviceStatusOperation operation = 3;
inline bool ImpactAnalysis::_internal_has_operation() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ImpactAnalysis::has_operation() const {
  return _internal_has_operation();
}
inline void ImpactAnalysis::clear_operation() {
  operation_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::video_widevine::ImpactAnalysis_DeviceStatusOperation ImpactAnalysis::_internal_operation() const {
  return static_cast< ::video_widevine::ImpactAnalysis_DeviceStatusOperation >(operation_);
}
inline ::video_widevine::ImpactAnalysis_DeviceStatusOperation ImpactAnalysis::operation() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.operation)
  return _internal_operation();
}
inline void ImpactAnalysis::_internal_set_operation(::video_widevine::ImpactAnalysis_DeviceStatusOperation value) {
  assert(::video_widevine::ImpactAnalysis_DeviceStatusOperation_IsValid(value));
  _has_bits_[0] |= 0x00000008u;
  operation_ = value;
}
inline void ImpactAnalysis::set_operation(::video_widevine::ImpactAnalysis_DeviceStatusOperation value) {
  _internal_set_operation(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.operation)
}

// optional uint32 operation_time_seconds = 4;
inline bool ImpactAnalysis::_internal_has_operation_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ImpactAnalysis::has_operation_time_seconds() const {
  return _internal_has_operation_time_seconds();
}
inline void ImpactAnalysis::clear_operation_time_seconds() {
  operation_time_seconds_ = 0u;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis::_internal_operation_time_seconds() const {
  return operation_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ImpactAnalysis::operation_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.operation_time_seconds)
  return _internal_operation_time_seconds();
}
inline void ImpactAnalysis::_internal_set_operation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000010u;
  operation_time_seconds_ = value;
}
inline void ImpactAnalysis::set_operation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_operation_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.ImpactAnalysis.operation_time_seconds)
}

// optional .video_widevine.ImpactAnalysis.ImpactAnalysisMetrics impact_analysis_metrics = 5;
inline bool ImpactAnalysis::_internal_has_impact_analysis_metrics() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || impact_analysis_metrics_ != nullptr);
  return value;
}
inline bool ImpactAnalysis::has_impact_analysis_metrics() const {
  return _internal_has_impact_analysis_metrics();
}
inline void ImpactAnalysis::clear_impact_analysis_metrics() {
  if (impact_analysis_metrics_ != nullptr) impact_analysis_metrics_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics& ImpactAnalysis::_internal_impact_analysis_metrics() const {
  const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* p = impact_analysis_metrics_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics&>(
      ::video_widevine::_ImpactAnalysis_ImpactAnalysisMetrics_default_instance_);
}
inline const ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics& ImpactAnalysis::impact_analysis_metrics() const {
  // @@protoc_insertion_point(field_get:video_widevine.ImpactAnalysis.impact_analysis_metrics)
  return _internal_impact_analysis_metrics();
}
inline void ImpactAnalysis::unsafe_arena_set_allocated_impact_analysis_metrics(
    ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* impact_analysis_metrics) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(impact_analysis_metrics_);
  }
  impact_analysis_metrics_ = impact_analysis_metrics;
  if (impact_analysis_metrics) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ImpactAnalysis.impact_analysis_metrics)
}
inline ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* ImpactAnalysis::release_impact_analysis_metrics() {
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* temp = impact_analysis_metrics_;
  impact_analysis_metrics_ = 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::ImpactAnalysis_ImpactAnalysisMetrics* ImpactAnalysis::unsafe_arena_release_impact_analysis_metrics() {
  // @@protoc_insertion_point(field_release:video_widevine.ImpactAnalysis.impact_analysis_metrics)
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* temp = impact_analysis_metrics_;
  impact_analysis_metrics_ = nullptr;
  return temp;
}
inline ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* ImpactAnalysis::_internal_mutable_impact_analysis_metrics() {
  _has_bits_[0] |= 0x00000001u;
  if (impact_analysis_metrics_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics>(GetArenaForAllocation());
    impact_analysis_metrics_ = p;
  }
  return impact_analysis_metrics_;
}
inline ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* ImpactAnalysis::mutable_impact_analysis_metrics() {
  ::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* _msg = _internal_mutable_impact_analysis_metrics();
  // @@protoc_insertion_point(field_mutable:video_widevine.ImpactAnalysis.impact_analysis_metrics)
  return _msg;
}
inline void ImpactAnalysis::set_allocated_impact_analysis_metrics(::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics* impact_analysis_metrics) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete impact_analysis_metrics_;
  }
  if (impact_analysis_metrics) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ImpactAnalysis_ImpactAnalysisMetrics>::GetOwningArena(impact_analysis_metrics);
    if (message_arena != submessage_arena) {
      impact_analysis_metrics = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, impact_analysis_metrics, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  impact_analysis_metrics_ = impact_analysis_metrics;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.ImpactAnalysis.impact_analysis_metrics)
}

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

// 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_;
}

// repeated .video_widevine.ImpactAnalysis impact_analysis = 3;
inline int DeviceCertificateStatusList::_internal_impact_analysis_size() const {
  return impact_analysis_.size();
}
inline int DeviceCertificateStatusList::impact_analysis_size() const {
  return _internal_impact_analysis_size();
}
inline void DeviceCertificateStatusList::clear_impact_analysis() {
  impact_analysis_.Clear();
}
inline ::video_widevine::ImpactAnalysis* DeviceCertificateStatusList::mutable_impact_analysis(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusList.impact_analysis)
  return impact_analysis_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >*
DeviceCertificateStatusList::mutable_impact_analysis() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatusList.impact_analysis)
  return &impact_analysis_;
}
inline const ::video_widevine::ImpactAnalysis& DeviceCertificateStatusList::_internal_impact_analysis(int index) const {
  return impact_analysis_.Get(index);
}
inline const ::video_widevine::ImpactAnalysis& DeviceCertificateStatusList::impact_analysis(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.impact_analysis)
  return _internal_impact_analysis(index);
}
inline ::video_widevine::ImpactAnalysis* DeviceCertificateStatusList::_internal_add_impact_analysis() {
  return impact_analysis_.Add();
}
inline ::video_widevine::ImpactAnalysis* DeviceCertificateStatusList::add_impact_analysis() {
  ::video_widevine::ImpactAnalysis* _add = _internal_add_impact_analysis();
  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatusList.impact_analysis)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >&
DeviceCertificateStatusList::impact_analysis() const {
  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatusList.impact_analysis)
  return impact_analysis_;
}

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

// 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_;
}

// repeated .video_widevine.ImpactAnalysis impact_analysis = 3;
inline int PublishedDevicesList::_internal_impact_analysis_size() const {
  return impact_analysis_.size();
}
inline int PublishedDevicesList::impact_analysis_size() const {
  return _internal_impact_analysis_size();
}
inline void PublishedDevicesList::clear_impact_analysis() {
  impact_analysis_.Clear();
}
inline ::video_widevine::ImpactAnalysis* PublishedDevicesList::mutable_impact_analysis(int index) {
  // @@protoc_insertion_point(field_mutable:video_widevine.PublishedDevicesList.impact_analysis)
  return impact_analysis_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >*
PublishedDevicesList::mutable_impact_analysis() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.PublishedDevicesList.impact_analysis)
  return &impact_analysis_;
}
inline const ::video_widevine::ImpactAnalysis& PublishedDevicesList::_internal_impact_analysis(int index) const {
  return impact_analysis_.Get(index);
}
inline const ::video_widevine::ImpactAnalysis& PublishedDevicesList::impact_analysis(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.impact_analysis)
  return _internal_impact_analysis(index);
}
inline ::video_widevine::ImpactAnalysis* PublishedDevicesList::_internal_add_impact_analysis() {
  return impact_analysis_.Add();
}
inline ::video_widevine::ImpactAnalysis* PublishedDevicesList::add_impact_analysis() {
  ::video_widevine::ImpactAnalysis* _add = _internal_add_impact_analysis();
  // @@protoc_insertion_point(field_add:video_widevine.PublishedDevicesList.impact_analysis)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ImpactAnalysis >&
PublishedDevicesList::impact_analysis() const {
  // @@protoc_insertion_point(field_list:video_widevine.PublishedDevicesList.impact_analysis)
  return impact_analysis_;
}

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

// 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::ImpactAnalysis_DeviceStatusOperation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ImpactAnalysis_DeviceStatusOperation>() {
  return ::video_widevine::ImpactAnalysis_DeviceStatusOperation_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::ImpactAnalysis_DeviceStatusImpact> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ImpactAnalysis_DeviceStatusImpact>() {
  return ::video_widevine::ImpactAnalysis_DeviceStatusImpact_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