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

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_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/client_identification.pb.h"
#include "protos/public/device_common.pb.h"
#include "protos/public/license_protocol.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_5fsecurity_5fprofile_5fdata_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_5fsecurity_5fprofile_5fdata_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
namespace video_widevine {
class BrowserRequirement;
struct BrowserRequirementDefaultTypeInternal;
extern BrowserRequirementDefaultTypeInternal _BrowserRequirement_default_instance_;
class ControlTime;
struct ControlTimeDefaultTypeInternal;
extern ControlTimeDefaultTypeInternal _ControlTime_default_instance_;
class DeviceException;
struct DeviceExceptionDefaultTypeInternal;
extern DeviceExceptionDefaultTypeInternal _DeviceException_default_instance_;
class OutputRequirement;
struct OutputRequirementDefaultTypeInternal;
extern OutputRequirementDefaultTypeInternal _OutputRequirement_default_instance_;
class SecurityRequirement;
struct SecurityRequirementDefaultTypeInternal;
extern SecurityRequirementDefaultTypeInternal _SecurityRequirement_default_instance_;
}  // namespace video_widevine
PROTOBUF_NAMESPACE_OPEN
template<> ::video_widevine::BrowserRequirement* Arena::CreateMaybeMessage<::video_widevine::BrowserRequirement>(Arena*);
template<> ::video_widevine::ControlTime* Arena::CreateMaybeMessage<::video_widevine::ControlTime>(Arena*);
template<> ::video_widevine::DeviceException* Arena::CreateMaybeMessage<::video_widevine::DeviceException>(Arena*);
template<> ::video_widevine::OutputRequirement* Arena::CreateMaybeMessage<::video_widevine::OutputRequirement>(Arena*);
template<> ::video_widevine::SecurityRequirement* Arena::CreateMaybeMessage<::video_widevine::SecurityRequirement>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace video_widevine {

enum DeviceException_ExceptionAction : int {
  DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED = 0,
  DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW = 1,
  DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK = 2
};
bool DeviceException_ExceptionAction_IsValid(int value);
constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MIN = DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MAX = DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
constexpr int DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE = DeviceException_ExceptionAction_ExceptionAction_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceException_ExceptionAction_descriptor();
template<typename T>
inline const std::string& DeviceException_ExceptionAction_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceException_ExceptionAction>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceException_ExceptionAction_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceException_ExceptionAction_descriptor(), enum_t_value);
}
inline bool DeviceException_ExceptionAction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceException_ExceptionAction* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceException_ExceptionAction>(
    DeviceException_ExceptionAction_descriptor(), name, value);
}
enum SecurityProfileLevel : int {
  SECURITY_PROFILE_LEVEL_UNDEFINED = 0,
  SECURITY_PROFILE_LEVEL_1 = 1,
  SECURITY_PROFILE_LEVEL_2 = 2,
  SECURITY_PROFILE_LEVEL_3 = 3,
  SECURITY_PROFILE_LEVEL_4 = 4,
  SECURITY_PROFILE_LEVEL_5 = 5
};
bool SecurityProfileLevel_IsValid(int value);
constexpr SecurityProfileLevel SecurityProfileLevel_MIN = SECURITY_PROFILE_LEVEL_UNDEFINED;
constexpr SecurityProfileLevel SecurityProfileLevel_MAX = SECURITY_PROFILE_LEVEL_5;
constexpr int SecurityProfileLevel_ARRAYSIZE = SecurityProfileLevel_MAX + 1;

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

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

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

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

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

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

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

  OutputRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OutputRequirement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const OutputRequirement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const OutputRequirement& 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(OutputRequirement* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.OutputRequirement";
  }
  protected:
  explicit OutputRequirement(::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 {
    kHdcpVersionFieldNumber = 1,
    kAnalogOutputCapabilitiesFieldNumber = 2,
  };
  // optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
  bool has_hdcp_version() const;
  private:
  bool _internal_has_hdcp_version() const;
  public:
  void clear_hdcp_version();
  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion hdcp_version() const;
  void set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
  private:
  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_hdcp_version() const;
  void _internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
  public:

  // optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
  bool has_analog_output_capabilities() const;
  private:
  bool _internal_has_analog_output_capabilities() const;
  public:
  void clear_analog_output_capabilities();
  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
  void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
  private:
  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
  void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
  public:

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

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

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

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

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

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

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

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

  SecurityRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SecurityRequirement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SecurityRequirement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SecurityRequirement& 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(SecurityRequirement* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.SecurityRequirement";
  }
  protected:
  explicit SecurityRequirement(::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 {
    kDeviceStatesFieldNumber = 6,
    kBrowserRequirementsFieldNumber = 7,
    kOemcryptoApiMajorVersionFieldNumber = 1,
    kSecurityLevelFieldNumber = 2,
    kResourceRatingTierFieldNumber = 3,
    kVulnerabilityLevelFieldNumber = 4,
    kVerifiedMakeModelFieldNumber = 5,
  };
  // repeated .video_widevine.DeviceState device_states = 6 [packed = true];
  int device_states_size() const;
  private:
  int _internal_device_states_size() const;
  public:
  void clear_device_states();
  private:
  ::video_widevine::DeviceState _internal_device_states(int index) const;
  void _internal_add_device_states(::video_widevine::DeviceState value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_device_states();
  public:
  ::video_widevine::DeviceState device_states(int index) const;
  void set_device_states(int index, ::video_widevine::DeviceState value);
  void add_device_states(::video_widevine::DeviceState value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& device_states() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_device_states();

  // optional .video_widevine.BrowserRequirement browser_requirements = 7;
  bool has_browser_requirements() const;
  private:
  bool _internal_has_browser_requirements() const;
  public:
  void clear_browser_requirements();
  const ::video_widevine::BrowserRequirement& browser_requirements() const;
  PROTOBUF_MUST_USE_RESULT ::video_widevine::BrowserRequirement* release_browser_requirements();
  ::video_widevine::BrowserRequirement* mutable_browser_requirements();
  void set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements);
  private:
  const ::video_widevine::BrowserRequirement& _internal_browser_requirements() const;
  ::video_widevine::BrowserRequirement* _internal_mutable_browser_requirements();
  public:
  void unsafe_arena_set_allocated_browser_requirements(
      ::video_widevine::BrowserRequirement* browser_requirements);
  ::video_widevine::BrowserRequirement* unsafe_arena_release_browser_requirements();

  // optional uint32 oemcrypto_api_major_version = 1;
  bool has_oemcrypto_api_major_version() const;
  private:
  bool _internal_has_oemcrypto_api_major_version() const;
  public:
  void clear_oemcrypto_api_major_version();
  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version() const;
  void set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oemcrypto_api_major_version() const;
  void _internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
  bool has_security_level() const;
  private:
  bool _internal_has_security_level() const;
  public:
  void clear_security_level();
  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel security_level() const;
  void set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
  private:
  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel _internal_security_level() const;
  void _internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
  public:

  // optional uint32 resource_rating_tier = 3;
  bool has_resource_rating_tier() const;
  private:
  bool _internal_has_resource_rating_tier() const;
  public:
  void clear_resource_rating_tier();
  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
  void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
  void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
  bool has_vulnerability_level() const;
  private:
  bool _internal_has_vulnerability_level() const;
  public:
  void clear_vulnerability_level();
  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
  private:
  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
  public:

  // optional bool verified_make_model = 5;
  bool has_verified_make_model() const;
  private:
  bool _internal_has_verified_make_model() const;
  public:
  void clear_verified_make_model();
  bool verified_make_model() const;
  void set_verified_make_model(bool value);
  private:
  bool _internal_verified_make_model() const;
  void _internal_set_verified_make_model(bool value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.SecurityRequirement)
 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::RepeatedField<int> device_states_;
  mutable std::atomic<int> _device_states_cached_byte_size_;
  ::video_widevine::BrowserRequirement* browser_requirements_;
  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version_;
  int security_level_;
  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
  int vulnerability_level_;
  bool verified_make_model_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  BrowserRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BrowserRequirement>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BrowserRequirement& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const BrowserRequirement& 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(BrowserRequirement* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.BrowserRequirement";
  }
  protected:
  explicit BrowserRequirement(::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 {
    kVmpStatusesFieldNumber = 1,
  };
  // repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
  int vmp_statuses_size() const;
  private:
  int _internal_vmp_statuses_size() const;
  public:
  void clear_vmp_statuses();
  private:
  ::video_widevine::PlatformVerificationStatus _internal_vmp_statuses(int index) const;
  void _internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_vmp_statuses();
  public:
  ::video_widevine::PlatformVerificationStatus vmp_statuses(int index) const;
  void set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value);
  void add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& vmp_statuses() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_vmp_statuses();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> vmp_statuses_;
  mutable std::atomic<int> _vmp_statuses_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  DeviceException* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceException>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceException& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DeviceException& 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(DeviceException* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.DeviceException";
  }
  protected:
  explicit DeviceException(::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 DeviceException_ExceptionAction ExceptionAction;
  static constexpr ExceptionAction DEVICE_EXCEPTION_UNSPECIFIED =
    DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
  static constexpr ExceptionAction DEVICE_EXCEPTION_ALLOW =
    DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW;
  static constexpr ExceptionAction DEVICE_EXCEPTION_BLOCK =
    DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
  static inline bool ExceptionAction_IsValid(int value) {
    return DeviceException_ExceptionAction_IsValid(value);
  }
  static constexpr ExceptionAction ExceptionAction_MIN =
    DeviceException_ExceptionAction_ExceptionAction_MIN;
  static constexpr ExceptionAction ExceptionAction_MAX =
    DeviceException_ExceptionAction_ExceptionAction_MAX;
  static constexpr int ExceptionAction_ARRAYSIZE =
    DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ExceptionAction_descriptor() {
    return DeviceException_ExceptionAction_descriptor();
  }
  template<typename T>
  static inline const std::string& ExceptionAction_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ExceptionAction>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ExceptionAction_Name.");
    return DeviceException_ExceptionAction_Name(enum_t_value);
  }
  static inline bool ExceptionAction_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ExceptionAction* value) {
    return DeviceException_ExceptionAction_Parse(name, value);
  }

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

  enum : int {
    kSystemIdFieldNumber = 1,
    kActionFieldNumber = 2,
  };
  // 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.DeviceException.ExceptionAction action = 2;
  bool has_action() const;
  private:
  bool _internal_has_action() const;
  public:
  void clear_action();
  ::video_widevine::DeviceException_ExceptionAction action() const;
  void set_action(::video_widevine::DeviceException_ExceptionAction value);
  private:
  ::video_widevine::DeviceException_ExceptionAction _internal_action() const;
  void _internal_set_action(::video_widevine::DeviceException_ExceptionAction value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.DeviceException)
 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::uint32 system_id_;
  int action_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  ControlTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ControlTime>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ControlTime& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ControlTime& 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(ControlTime* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "video_widevine.ControlTime";
  }
  protected:
  explicit ControlTime(::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 {
    kStartTimeSecondsFieldNumber = 1,
    kEndTimeSecondsFieldNumber = 2,
  };
  // optional int64 start_time_seconds = 1;
  bool has_start_time_seconds() const;
  private:
  bool _internal_has_start_time_seconds() const;
  public:
  void clear_start_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds() const;
  void set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_start_time_seconds() const;
  void _internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 end_time_seconds = 2 [default = 0];
  bool has_end_time_seconds() const;
  private:
  bool _internal_has_end_time_seconds() const;
  public:
  void clear_end_time_seconds();
  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds() const;
  void set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end_time_seconds() const;
  void _internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:video_widevine.ControlTime)
 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::int64 start_time_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds_;
  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
};
// ===================================================================


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

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

// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
inline bool OutputRequirement::_internal_has_hdcp_version() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool OutputRequirement::has_hdcp_version() const {
  return _internal_has_hdcp_version();
}
inline void OutputRequirement::clear_hdcp_version() {
  hdcp_version_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::_internal_hdcp_version() const {
  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(hdcp_version_);
}
inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::hdcp_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.hdcp_version)
  return _internal_hdcp_version();
}
inline void OutputRequirement::_internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
  assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  hdcp_version_ = value;
}
inline void OutputRequirement::set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
  _internal_set_hdcp_version(value);
  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.hdcp_version)
}

// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
inline bool OutputRequirement::_internal_has_analog_output_capabilities() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool OutputRequirement::has_analog_output_capabilities() const {
  return _internal_has_analog_output_capabilities();
}
inline void OutputRequirement::clear_analog_output_capabilities() {
  analog_output_capabilities_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::_internal_analog_output_capabilities() const {
  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
}
inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::analog_output_capabilities() const {
  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.analog_output_capabilities)
  return _internal_analog_output_capabilities();
}
inline void OutputRequirement::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
  assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  analog_output_capabilities_ = value;
}
inline void OutputRequirement::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
  _internal_set_analog_output_capabilities(value);
  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.analog_output_capabilities)
}

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

// SecurityRequirement

// optional uint32 oemcrypto_api_major_version = 1;
inline bool SecurityRequirement::_internal_has_oemcrypto_api_major_version() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SecurityRequirement::has_oemcrypto_api_major_version() const {
  return _internal_has_oemcrypto_api_major_version();
}
inline void SecurityRequirement::clear_oemcrypto_api_major_version() {
  oemcrypto_api_major_version_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_oemcrypto_api_major_version() const {
  return oemcrypto_api_major_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::oemcrypto_api_major_version() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
  return _internal_oemcrypto_api_major_version();
}
inline void SecurityRequirement::_internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  oemcrypto_api_major_version_ = value;
}
inline void SecurityRequirement::set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_oemcrypto_api_major_version(value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
}

// optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
inline bool SecurityRequirement::_internal_has_security_level() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SecurityRequirement::has_security_level() const {
  return _internal_has_security_level();
}
inline void SecurityRequirement::clear_security_level() {
  security_level_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::_internal_security_level() const {
  return static_cast< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel >(security_level_);
}
inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::security_level() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.security_level)
  return _internal_security_level();
}
inline void SecurityRequirement::_internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
  assert(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  security_level_ = value;
}
inline void SecurityRequirement::set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
  _internal_set_security_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.security_level)
}

// optional uint32 resource_rating_tier = 3;
inline bool SecurityRequirement::_internal_has_resource_rating_tier() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SecurityRequirement::has_resource_rating_tier() const {
  return _internal_has_resource_rating_tier();
}
inline void SecurityRequirement::clear_resource_rating_tier() {
  resource_rating_tier_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_resource_rating_tier() const {
  return resource_rating_tier_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::resource_rating_tier() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.resource_rating_tier)
  return _internal_resource_rating_tier();
}
inline void SecurityRequirement::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  resource_rating_tier_ = value;
}
inline void SecurityRequirement::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_resource_rating_tier(value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.resource_rating_tier)
}

// optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
inline bool SecurityRequirement::_internal_has_vulnerability_level() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SecurityRequirement::has_vulnerability_level() const {
  return _internal_has_vulnerability_level();
}
inline void SecurityRequirement::clear_vulnerability_level() {
  vulnerability_level_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::video_widevine::VulnerabilityLevel SecurityRequirement::_internal_vulnerability_level() const {
  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
}
inline ::video_widevine::VulnerabilityLevel SecurityRequirement::vulnerability_level() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.vulnerability_level)
  return _internal_vulnerability_level();
}
inline void SecurityRequirement::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
  assert(::video_widevine::VulnerabilityLevel_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  vulnerability_level_ = value;
}
inline void SecurityRequirement::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
  _internal_set_vulnerability_level(value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.vulnerability_level)
}

// optional bool verified_make_model = 5;
inline bool SecurityRequirement::_internal_has_verified_make_model() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SecurityRequirement::has_verified_make_model() const {
  return _internal_has_verified_make_model();
}
inline void SecurityRequirement::clear_verified_make_model() {
  verified_make_model_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool SecurityRequirement::_internal_verified_make_model() const {
  return verified_make_model_;
}
inline bool SecurityRequirement::verified_make_model() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.verified_make_model)
  return _internal_verified_make_model();
}
inline void SecurityRequirement::_internal_set_verified_make_model(bool value) {
  _has_bits_[0] |= 0x00000020u;
  verified_make_model_ = value;
}
inline void SecurityRequirement::set_verified_make_model(bool value) {
  _internal_set_verified_make_model(value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.verified_make_model)
}

// repeated .video_widevine.DeviceState device_states = 6 [packed = true];
inline int SecurityRequirement::_internal_device_states_size() const {
  return device_states_.size();
}
inline int SecurityRequirement::device_states_size() const {
  return _internal_device_states_size();
}
inline void SecurityRequirement::clear_device_states() {
  device_states_.Clear();
}
inline ::video_widevine::DeviceState SecurityRequirement::_internal_device_states(int index) const {
  return static_cast< ::video_widevine::DeviceState >(device_states_.Get(index));
}
inline ::video_widevine::DeviceState SecurityRequirement::device_states(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.device_states)
  return _internal_device_states(index);
}
inline void SecurityRequirement::set_device_states(int index, ::video_widevine::DeviceState value) {
  assert(::video_widevine::DeviceState_IsValid(value));
  device_states_.Set(index, value);
  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.device_states)
}
inline void SecurityRequirement::_internal_add_device_states(::video_widevine::DeviceState value) {
  assert(::video_widevine::DeviceState_IsValid(value));
  device_states_.Add(value);
}
inline void SecurityRequirement::add_device_states(::video_widevine::DeviceState value) {
  _internal_add_device_states(value);
  // @@protoc_insertion_point(field_add:video_widevine.SecurityRequirement.device_states)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SecurityRequirement::device_states() const {
  // @@protoc_insertion_point(field_list:video_widevine.SecurityRequirement.device_states)
  return device_states_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SecurityRequirement::_internal_mutable_device_states() {
  return &device_states_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SecurityRequirement::mutable_device_states() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecurityRequirement.device_states)
  return _internal_mutable_device_states();
}

// optional .video_widevine.BrowserRequirement browser_requirements = 7;
inline bool SecurityRequirement::_internal_has_browser_requirements() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || browser_requirements_ != nullptr);
  return value;
}
inline bool SecurityRequirement::has_browser_requirements() const {
  return _internal_has_browser_requirements();
}
inline void SecurityRequirement::clear_browser_requirements() {
  if (browser_requirements_ != nullptr) browser_requirements_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::video_widevine::BrowserRequirement& SecurityRequirement::_internal_browser_requirements() const {
  const ::video_widevine::BrowserRequirement* p = browser_requirements_;
  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::BrowserRequirement&>(
      ::video_widevine::_BrowserRequirement_default_instance_);
}
inline const ::video_widevine::BrowserRequirement& SecurityRequirement::browser_requirements() const {
  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.browser_requirements)
  return _internal_browser_requirements();
}
inline void SecurityRequirement::unsafe_arena_set_allocated_browser_requirements(
    ::video_widevine::BrowserRequirement* browser_requirements) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(browser_requirements_);
  }
  browser_requirements_ = browser_requirements;
  if (browser_requirements) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
}
inline ::video_widevine::BrowserRequirement* SecurityRequirement::release_browser_requirements() {
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
  browser_requirements_ = 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::BrowserRequirement* SecurityRequirement::unsafe_arena_release_browser_requirements() {
  // @@protoc_insertion_point(field_release:video_widevine.SecurityRequirement.browser_requirements)
  _has_bits_[0] &= ~0x00000001u;
  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
  browser_requirements_ = nullptr;
  return temp;
}
inline ::video_widevine::BrowserRequirement* SecurityRequirement::_internal_mutable_browser_requirements() {
  _has_bits_[0] |= 0x00000001u;
  if (browser_requirements_ == nullptr) {
    auto* p = CreateMaybeMessage<::video_widevine::BrowserRequirement>(GetArenaForAllocation());
    browser_requirements_ = p;
  }
  return browser_requirements_;
}
inline ::video_widevine::BrowserRequirement* SecurityRequirement::mutable_browser_requirements() {
  ::video_widevine::BrowserRequirement* _msg = _internal_mutable_browser_requirements();
  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityRequirement.browser_requirements)
  return _msg;
}
inline void SecurityRequirement::set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete browser_requirements_;
  }
  if (browser_requirements) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::BrowserRequirement>::GetOwningArena(browser_requirements);
    if (message_arena != submessage_arena) {
      browser_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, browser_requirements, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  browser_requirements_ = browser_requirements;
  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
}

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

// BrowserRequirement

// repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
inline int BrowserRequirement::_internal_vmp_statuses_size() const {
  return vmp_statuses_.size();
}
inline int BrowserRequirement::vmp_statuses_size() const {
  return _internal_vmp_statuses_size();
}
inline void BrowserRequirement::clear_vmp_statuses() {
  vmp_statuses_.Clear();
}
inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::_internal_vmp_statuses(int index) const {
  return static_cast< ::video_widevine::PlatformVerificationStatus >(vmp_statuses_.Get(index));
}
inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::vmp_statuses(int index) const {
  // @@protoc_insertion_point(field_get:video_widevine.BrowserRequirement.vmp_statuses)
  return _internal_vmp_statuses(index);
}
inline void BrowserRequirement::set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value) {
  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
  vmp_statuses_.Set(index, value);
  // @@protoc_insertion_point(field_set:video_widevine.BrowserRequirement.vmp_statuses)
}
inline void BrowserRequirement::_internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
  vmp_statuses_.Add(value);
}
inline void BrowserRequirement::add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
  _internal_add_vmp_statuses(value);
  // @@protoc_insertion_point(field_add:video_widevine.BrowserRequirement.vmp_statuses)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
BrowserRequirement::vmp_statuses() const {
  // @@protoc_insertion_point(field_list:video_widevine.BrowserRequirement.vmp_statuses)
  return vmp_statuses_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BrowserRequirement::_internal_mutable_vmp_statuses() {
  return &vmp_statuses_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BrowserRequirement::mutable_vmp_statuses() {
  // @@protoc_insertion_point(field_mutable_list:video_widevine.BrowserRequirement.vmp_statuses)
  return _internal_mutable_vmp_statuses();
}

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

// DeviceException

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

// optional .video_widevine.DeviceException.ExceptionAction action = 2;
inline bool DeviceException::_internal_has_action() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceException::has_action() const {
  return _internal_has_action();
}
inline void DeviceException::clear_action() {
  action_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::video_widevine::DeviceException_ExceptionAction DeviceException::_internal_action() const {
  return static_cast< ::video_widevine::DeviceException_ExceptionAction >(action_);
}
inline ::video_widevine::DeviceException_ExceptionAction DeviceException::action() const {
  // @@protoc_insertion_point(field_get:video_widevine.DeviceException.action)
  return _internal_action();
}
inline void DeviceException::_internal_set_action(::video_widevine::DeviceException_ExceptionAction value) {
  assert(::video_widevine::DeviceException_ExceptionAction_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  action_ = value;
}
inline void DeviceException::set_action(::video_widevine::DeviceException_ExceptionAction value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:video_widevine.DeviceException.action)
}

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

// ControlTime

// optional int64 start_time_seconds = 1;
inline bool ControlTime::_internal_has_start_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ControlTime::has_start_time_seconds() const {
  return _internal_has_start_time_seconds();
}
inline void ControlTime::clear_start_time_seconds() {
  start_time_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_start_time_seconds() const {
  return start_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::start_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.start_time_seconds)
  return _internal_start_time_seconds();
}
inline void ControlTime::_internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  start_time_seconds_ = value;
}
inline void ControlTime::set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_start_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.start_time_seconds)
}

// optional int64 end_time_seconds = 2 [default = 0];
inline bool ControlTime::_internal_has_end_time_seconds() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ControlTime::has_end_time_seconds() const {
  return _internal_has_end_time_seconds();
}
inline void ControlTime::clear_end_time_seconds() {
  end_time_seconds_ = int64_t{0};
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_end_time_seconds() const {
  return end_time_seconds_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::end_time_seconds() const {
  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.end_time_seconds)
  return _internal_end_time_seconds();
}
inline void ControlTime::_internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  end_time_seconds_ = value;
}
inline void ControlTime::set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_end_time_seconds(value);
  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.end_time_seconds)
}

#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::DeviceException_ExceptionAction> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceException_ExceptionAction>() {
  return ::video_widevine::DeviceException_ExceptionAction_descriptor();
}
template <> struct is_proto_enum< ::video_widevine::SecurityProfileLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SecurityProfileLevel>() {
  return ::video_widevine::SecurityProfileLevel_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_5fsecurity_5fprofile_5fdata_2eproto